Initial commit

.gitattributes

@@ -0,0 +1,57 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.lz4 filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+# Audio files - uncompressed
+*.pcm filter=lfs diff=lfs merge=lfs -text
+*.sam filter=lfs diff=lfs merge=lfs -text
+*.raw filter=lfs diff=lfs merge=lfs -text
+# Audio files - compressed
+*.aac filter=lfs diff=lfs merge=lfs -text
+*.flac filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.ogg filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+# Image files - uncompressed
+*.bmp filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text
+*.tiff filter=lfs diff=lfs merge=lfs -text
+# Image files - compressed
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.webp filter=lfs diff=lfs merge=lfs -text
+
+address_bytecodehash_index filter=lfs diff=lfs merge=lfs -text
+

README.md

@@ -0,0 +1,50 @@
+---
+language:
+- en
+tags:
+- solidity
+- blockchain
+- ethereum
+- smart-contract
+pretty_name: Zellic Smart Contract Source Index
+size_categories:
+- 100K<n<1M
+---
+# Zellic 2023 Smart Contract Source Index
+
+Zellic is making publicly available a dataset of known Ethereum mainnet smart contract source code.
+
+Our aim is to provide a contract source code dataset that is readily available to the public to download in bulk. We believe this dataset will help advance the frontier of smart contract security research. Applications include static analysis, machine learning, and more. This effort is part of Zellic’s mission to create a world with no smart contract hacks.
+
+We used a custom fork of Geth to accumulate a list of all deployed contracts on Ethereum mainnet as of block 16860349. This list does not include contracts that are selfdestructed. Next, we deduplicated contract addresses by runtime bytecode. Finally, we cross-referenced this list with online sources of contract source code. All data was obtained from publicly available sources.
+
+## Dataset Structure
+
+### Index
+
+The `address_bytecodehash_index` file contains a list of known smart contract addresses mapped to the Keccak256 hash of their EVM bytecode.
+
+Look up the smart contract address in this file to find the source. This file also serves as a list of all deployed smart contracts as of block 16860349.
+
+### Contract Sources
+
+Smart Contract sources are organized by folder in the `organized_contracts` directory.
+
+For example, a contract with the bytecode hash `beef3d7d1884c4fee50548cfe762415fe494e3feb1e6ca181352ef023ba1ff7a` would be in the directory `organized_contracts/be/beef3d7d1884c4fee50548cfe762415fe494e3feb1e6ca181352ef023ba1ff7a/`.
+
+Each folder for a smart contract contains the source files as well as a `metadata.json` that contains information about the contract such as the compiler version and optimizations used. These settings can be used to attempt to reproduce the build.
+
+#### Source Formats
+
+Contracts may come in one of three source formats. Single file, multiple files, and [Solidity Compiler JSON](https://docs.soliditylang.org/en/v0.8.19/using-the-compiler.html#compiler-api).
+
+For single and multiple file contacts, each `.sol` file will be included in the directory. Single file contracts will be named `main.sol`.
+
+For Solidity Compiler Input JSON, the compiler input will be stored in `contract.json`.
+
+## Notices
+
+The smart contract source code in this dataset were obtained from publicly available sources. You should always abide by the appropriate code and software licenses, as well as all applicable copyright law.
+
+THE DATASET/SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE DATASET/SOFTWARE OR THE USE OR OTHER DEALINGS IN THE DATASET/SOFTWARE.
+

address_bytecodehash_index

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b3e0a87be53b1fbf88a72877aca628b9e3f94f8d23de278b1a4c8bfceb9febd8
+size 3242185549

organized_contracts/00/0000f2d83ae998c42325ec38f81c0cd1694a48cb50e46fd373c1468f548f66f3/contract.json

@@ -0,0 +1,102 @@
+{
+  "language": "Solidity",
+  "settings": {
+    "evmVersion": "london",
+    "libraries": {},
+    "metadata": {
+      "bytecodeHash": "ipfs",
+      "useLiteralContent": true
+    },
+    "optimizer": {
+      "enabled": true,
+      "runs": 200
+    },
+    "remappings": [],
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    }
+  },
+  "sources": {
+    "contracts/Pool.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"./dependencies/openzeppelin/security/ReentrancyGuard.sol\";\nimport \"./storage/PoolStorage.sol\";\nimport \"./lib/WadRayMath.sol\";\nimport \"./utils/Pauseable.sol\";\n\n/**\n * @title Pool contract\n */\ncontract Pool is ReentrancyGuard, Pauseable, PoolStorageV1 {\n    using SafeERC20 for IERC20;\n    using WadRayMath for uint256;\n    using EnumerableSet for EnumerableSet.AddressSet;\n    using MappedEnumerableSet for MappedEnumerableSet.AddressSet;\n\n    string public constant VERSION = \"1.0.0\";\n\n    /// @notice Emitted when protocol liquidation fee is updated\n    event DebtFloorUpdated(uint256 oldDebtFloorInUsd, uint256 newDebtFloorInUsd);\n\n    /// @notice Emitted when debt token is enabled\n    event DebtTokenAdded(IDebtToken indexed debtToken);\n\n    /// @notice Emitted when debt token is disabled\n    event DebtTokenRemoved(IDebtToken indexed debtToken);\n\n    /// @notice Emitted when deposit fee is updated\n    event DepositFeeUpdated(uint256 oldDepositFee, uint256 newDepositFee);\n\n    /// @notice Emitted when deposit token is enabled\n    event DepositTokenAdded(address indexed depositToken);\n\n    /// @notice Emitted when deposit token is disabled\n    event DepositTokenRemoved(IDepositToken indexed depositToken);\n\n    /// @notice Emitted when issue fee is updated\n    event IssueFeeUpdated(uint256 oldIssueFee, uint256 newIssueFee);\n\n    /// @notice Emitted when liquidator liquidation fee is updated\n    event LiquidatorLiquidationFeeUpdated(uint256 oldLiquidatorLiquidationFee, uint256 newLiquidatorLiquidationFee);\n\n    /// @notice Emitted when maxLiquidable (liquidation cap) is updated\n    event MaxLiquidableUpdated(uint256 oldMaxLiquidable, uint256 newMaxLiquidable);\n\n    /// @notice Emitted when a position is liquidated\n    event PositionLiquidated(\n        address indexed liquidator,\n        address indexed account,\n        ISyntheticToken indexed syntheticToken,\n        uint256 amountRepaid,\n        uint256 depositSeized,\n        uint256 fee\n    );\n\n    /// @notice Emitted when protocol liquidation fee is updated\n    event ProtocolLiquidationFeeUpdated(uint256 oldProtocolLiquidationFee, uint256 newProtocolLiquidationFee);\n\n    /// @notice Emitted when repay fee is updated\n    event RepayFeeUpdated(uint256 oldRepayFee, uint256 newRepayFee);\n\n    /// @notice Emitted when rewards distributor contract is added\n    event RewardsDistributorAdded(IRewardsDistributor _distributor);\n\n    /// @notice Emitted when rewards distributor contract is removed\n    event RewardsDistributorRemoved(IRewardsDistributor _distributor);\n\n    /// @notice Emitted when swap fee is updated\n    event SwapFeeUpdated(uint256 oldSwapFee, uint256 newSwapFee);\n\n    /// @notice Emitted when the swap active flag is updated\n    event SwapActiveUpdated(bool newActive);\n\n    /// @notice Emitted when synthetic token is swapped\n    event SyntheticTokenSwapped(\n        address indexed account,\n        ISyntheticToken indexed syntheticTokenIn,\n        ISyntheticToken indexed syntheticTokenOut,\n        uint256 amountIn,\n        uint256 amountOut,\n        uint256 fee\n    );\n\n    /// @notice Emitted when treasury contract is updated\n    event TreasuryUpdated(ITreasury indexed oldTreasury, ITreasury indexed newTreasury);\n\n    /// @notice Emitted when withdraw fee is updated\n    event WithdrawFeeUpdated(uint256 oldWithdrawFee, uint256 newWithdrawFee);\n\n    /**\n     * @dev Throws if deposit token doesn't exist\n     */\n    modifier onlyIfDepositTokenExists(IDepositToken depositToken_) {\n        require(isDepositTokenExists(depositToken_), \"collateral-inexistent\");\n        _;\n    }\n\n    /**\n     * @dev Throws if synthetic token doesn't exist\n     */\n    modifier onlyIfSyntheticTokenExists(ISyntheticToken syntheticToken_) {\n        require(isSyntheticTokenExists(syntheticToken_), \"synthetic-inexistent\");\n        _;\n    }\n\n    /**\n     * @dev Throws if `msg.sender` isn't a debt token\n     */\n    modifier onlyIfMsgSenderIsDebtToken() {\n        require(isDebtTokenExists(IDebtToken(msg.sender)), \"caller-is-not-debt-token\");\n        _;\n    }\n\n    function initialize(IPoolRegistry poolRegistry_) public initializer {\n        require(address(poolRegistry_) != address(0), \"pool-registry-is-null\");\n        __ReentrancyGuard_init();\n        __Pauseable_init();\n\n        poolRegistry = poolRegistry_;\n        isSwapActive = true;\n\n        repayFee = 3e15; // 0.3%\n        liquidationFees = LiquidationFees({\n            liquidatorFee: 1e17, // 10%\n            protocolFee: 8e16 // 8%\n        });\n        maxLiquidable = 0.5e18; // 50%\n        swapFee = 6e15; // 0.6%\n    }\n\n    /**\n     * @notice Add a debt token to the per-account list\n     * @dev This function is called from `DebtToken` when user's balance changes from `0`\n     * @dev The caller should ensure to not pass `address(0)` as `_account`\n     * @param account_ The account address\n     */\n    function addToDebtTokensOfAccount(address account_) external onlyIfMsgSenderIsDebtToken {\n        require(debtTokensOfAccount.add(account_, msg.sender), \"debt-token-exists\");\n    }\n\n    /**\n     * @notice Add a deposit token to the per-account list\n     * @dev This function is called from `DepositToken` when user's balance changes from `0`\n     * @dev The caller should ensure to not pass `address(0)` as `_account`\n     * @param account_ The account address\n     */\n    function addToDepositTokensOfAccount(address account_) external {\n        require(depositTokens.contains(msg.sender), \"caller-is-not-deposit-token\");\n        require(depositTokensOfAccount.add(account_, msg.sender), \"deposit-token-exists\");\n    }\n\n    /**\n     * @notice Get account's debt by querying latest prices from oracles\n     * @param account_ The account to check\n     * @return _debtInUsd The debt value in USD\n     */\n    function debtOf(address account_) public view override returns (uint256 _debtInUsd) {\n        IMasterOracle _masterOracle = masterOracle();\n        uint256 _length = debtTokensOfAccount.length(account_);\n        for (uint256 i; i < _length; ++i) {\n            IDebtToken _debtToken = IDebtToken(debtTokensOfAccount.at(account_, i));\n            _debtInUsd += _masterOracle.quoteTokenToUsd(\n                address(_debtToken.syntheticToken()),\n                _debtToken.balanceOf(account_)\n            );\n        }\n    }\n\n    /**\n     * @notice Get if the debt position from an account is healthy\n     * @param account_ The account to check\n     * @return _isHealthy Whether the account's position is healthy\n     * @return _depositInUsd The total collateral deposited in USD\n     * @return _debtInUsd The total debt in USD\n     * @return _issuableLimitInUsd The max amount of debt (is USD) that can be created (considering collateralization ratios)\n     * @return _issuableInUsd The amount of debt (is USD) that is free (i.e. can be used to issue synthetic tokens)\n     */\n    function debtPositionOf(address account_)\n        public\n        view\n        override\n        returns (\n            bool _isHealthy,\n            uint256 _depositInUsd,\n            uint256 _debtInUsd,\n            uint256 _issuableLimitInUsd,\n            uint256 _issuableInUsd\n        )\n    {\n        _debtInUsd = debtOf(account_);\n        (_depositInUsd, _issuableLimitInUsd) = depositOf(account_);\n        _isHealthy = _debtInUsd <= _issuableLimitInUsd;\n        _issuableInUsd = _debtInUsd < _issuableLimitInUsd ? _issuableLimitInUsd - _debtInUsd : 0;\n    }\n\n    /**\n     * @notice Get account's total collateral deposited by querying latest prices from oracles\n     * @param account_ The account to check\n     * @return _depositInUsd The total deposit value in USD among all collaterals\n     * @return _issuableLimitInUsd The max value in USD that can be used to issue synthetic tokens\n     */\n    function depositOf(address account_)\n        public\n        view\n        override\n        returns (uint256 _depositInUsd, uint256 _issuableLimitInUsd)\n    {\n        IMasterOracle _masterOracle = masterOracle();\n        uint256 _length = depositTokensOfAccount.length(account_);\n        for (uint256 i; i < _length; ++i) {\n            IDepositToken _depositToken = IDepositToken(depositTokensOfAccount.at(account_, i));\n            uint256 _amountInUsd = _masterOracle.quoteTokenToUsd(\n                address(_depositToken.underlying()),\n                _depositToken.balanceOf(account_)\n            );\n            _depositInUsd += _amountInUsd;\n            _issuableLimitInUsd += _amountInUsd.wadMul(_depositToken.collateralizationRatio());\n        }\n    }\n\n    /**\n     * @inheritdoc Pauseable\n     */\n    function everythingStopped() public view override(IPauseable, Pauseable) returns (bool) {\n        return super.everythingStopped() || poolRegistry.everythingStopped();\n    }\n\n    /**\n     * @notice Returns fee collector address\n     */\n    function feeCollector() external view returns (address) {\n        return poolRegistry.feeCollector();\n    }\n\n    /**\n     * @notice Get all debt tokens\n     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees.\n     */\n    function getDebtTokens() external view override returns (address[] memory) {\n        return debtTokens.values();\n    }\n\n    /**\n     * @notice Get all debt tokens\n     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees.\n     */\n    function getDebtTokensOfAccount(address account_) external view override returns (address[] memory) {\n        return debtTokensOfAccount.values(account_);\n    }\n\n    /**\n     * @notice Get all deposit tokens\n     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees.\n     */\n    function getDepositTokens() external view override returns (address[] memory) {\n        return depositTokens.values();\n    }\n\n    /**\n     * @notice Get deposit tokens of an account\n     * @dev WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees.\n     */\n    function getDepositTokensOfAccount(address account_) external view override returns (address[] memory) {\n        return depositTokensOfAccount.values(account_);\n    }\n\n    /**\n     * @notice Get all rewards distributors\n     */\n    function getRewardsDistributors() external view override returns (IRewardsDistributor[] memory) {\n        return rewardsDistributors;\n    }\n\n    /**\n     * @notice Check if token is part of the debt offerings\n     * @param debtToken_ Asset to check\n     * @return true if exist\n     */\n    function isDebtTokenExists(IDebtToken debtToken_) public view override returns (bool) {\n        return debtTokens.contains(address(debtToken_));\n    }\n\n    /**\n     * @notice Check if collateral is supported\n     * @param depositToken_ Asset to check\n     * @return true if exist\n     */\n    function isDepositTokenExists(IDepositToken depositToken_) public view override returns (bool) {\n        return depositTokens.contains(address(depositToken_));\n    }\n\n    /**\n     * @notice Check if token is part of the synthetic offerings\n     * @param syntheticToken_ Asset to check\n     * @return true if exist\n     */\n    function isSyntheticTokenExists(ISyntheticToken syntheticToken_) public view override returns (bool) {\n        return address(debtTokenOf[syntheticToken_]) != address(0);\n    }\n\n    /**\n     * @notice Burn synthetic token, unlock deposit token and send liquidator liquidation fee\n     * @param syntheticToken_ The msAsset to use for repayment\n     * @param account_ The account with an unhealthy position\n     * @param amountToRepay_ The amount to repay in synthetic token\n     * @param depositToken_ The collateral to seize from\n     */\n    function liquidate(\n        ISyntheticToken syntheticToken_,\n        address account_,\n        uint256 amountToRepay_,\n        IDepositToken depositToken_\n    ) external override whenNotShutdown nonReentrant onlyIfDepositTokenExists(depositToken_) {\n        require(amountToRepay_ > 0, \"amount-is-zero\");\n        require(msg.sender != account_, \"can-not-liquidate-own-position\");\n\n        IDebtToken _debtToken = debtTokenOf[syntheticToken_];\n        _debtToken.accrueInterest();\n\n        (bool _isHealthy, , , , ) = debtPositionOf(account_);\n\n        require(!_isHealthy, \"position-is-healthy\");\n\n        uint256 _debtTokenBalance = _debtToken.balanceOf(account_);\n\n        require(amountToRepay_.wadDiv(_debtTokenBalance) <= maxLiquidable, \"amount-gt-max-liquidable\");\n\n        IMasterOracle _masterOracle = masterOracle();\n\n        if (debtFloorInUsd > 0) {\n            uint256 _newDebtInUsd = _masterOracle.quoteTokenToUsd(\n                address(syntheticToken_),\n                _debtTokenBalance - amountToRepay_\n            );\n            require(_newDebtInUsd == 0 || _newDebtInUsd >= debtFloorInUsd, \"remaining-debt-lt-floor\");\n        }\n\n        uint256 _amountToRepayInCollateral = _masterOracle.quote(\n            address(syntheticToken_),\n            address(depositToken_.underlying()),\n            amountToRepay_\n        );\n\n        LiquidationFees memory _fees = liquidationFees;\n\n        uint256 _toProtocol = _fees.protocolFee > 0 ? _amountToRepayInCollateral.wadMul(_fees.protocolFee) : 0;\n        uint256 _toLiquidator = _amountToRepayInCollateral.wadMul(1e18 + _fees.liquidatorFee);\n        uint256 _depositToSeize = _toProtocol + _toLiquidator;\n\n        require(_depositToSeize <= depositToken_.balanceOf(account_), \"amount-too-high\");\n\n        syntheticToken_.burn(msg.sender, amountToRepay_);\n        _debtToken.burn(account_, amountToRepay_);\n        depositToken_.seize(account_, msg.sender, _toLiquidator);\n\n        if (_toProtocol > 0) {\n            depositToken_.seize(account_, poolRegistry.feeCollector(), _toProtocol);\n        }\n\n        emit PositionLiquidated(msg.sender, account_, syntheticToken_, amountToRepay_, _depositToSeize, _toProtocol);\n    }\n\n    /**\n     * @notice Get MasterOracle contract\n     */\n    function masterOracle() public view override returns (IMasterOracle) {\n        return poolRegistry.masterOracle();\n    }\n\n    /**\n     * @inheritdoc Pauseable\n     */\n    function paused() public view override(IPauseable, Pauseable) returns (bool) {\n        return super.paused() || poolRegistry.paused();\n    }\n\n    /**\n     * @notice Remove a debt token from the per-account list\n     * @dev This function is called from `DebtToken` when user's balance changes to `0`\n     * @dev The caller should ensure to not pass `address(0)` as `_account`\n     * @param account_ The account address\n     */\n    function removeFromDebtTokensOfAccount(address account_) external onlyIfMsgSenderIsDebtToken {\n        require(debtTokensOfAccount.remove(account_, msg.sender), \"debt-token-doesnt-exist\");\n    }\n\n    /**\n     * @notice Remove a deposit token from the per-account list\n     * @dev This function is called from `DepositToken` when user's balance changes to `0`\n     * @dev The caller should ensure to not pass `address(0)` as `_account`\n     * @param account_ The account address\n     */\n    function removeFromDepositTokensOfAccount(address account_) external {\n        require(depositTokens.contains(msg.sender), \"caller-is-not-deposit-token\");\n        require(depositTokensOfAccount.remove(account_, msg.sender), \"deposit-token-doesnt-exist\");\n    }\n\n    /**\n     * @notice Swap synthetic tokens\n     * @param syntheticTokenIn_ Synthetic token to sell\n     * @param syntheticTokenOut_ Synthetic token to buy\n     * @param amountIn_ Amount to swap\n     */\n    function swap(\n        ISyntheticToken syntheticTokenIn_,\n        ISyntheticToken syntheticTokenOut_,\n        uint256 amountIn_\n    )\n        external\n        override\n        whenNotShutdown\n        nonReentrant\n        onlyIfSyntheticTokenExists(syntheticTokenIn_)\n        onlyIfSyntheticTokenExists(syntheticTokenOut_)\n        returns (uint256 _amountOut)\n    {\n        require(isSwapActive, \"swap-is-off\");\n        require(amountIn_ > 0 && amountIn_ <= syntheticTokenIn_.balanceOf(msg.sender), \"amount-in-is-invalid\");\n        syntheticTokenIn_.burn(msg.sender, amountIn_);\n\n        _amountOut = poolRegistry.masterOracle().quote(\n            address(syntheticTokenIn_),\n            address(syntheticTokenOut_),\n            amountIn_\n        );\n\n        uint256 _feeAmount;\n        if (swapFee > 0) {\n            _feeAmount = _amountOut.wadMul(swapFee);\n            syntheticTokenOut_.mint(poolRegistry.feeCollector(), _feeAmount);\n            _amountOut -= _feeAmount;\n        }\n\n        syntheticTokenOut_.mint(msg.sender, _amountOut);\n\n        emit SyntheticTokenSwapped(\n            msg.sender,\n            syntheticTokenIn_,\n            syntheticTokenOut_,\n            amountIn_,\n            _amountOut,\n            _feeAmount\n        );\n    }\n\n    /**\n     * @notice Add debt token to offerings\n     * @dev Must keep `debtTokenOf` mapping updated\n     */\n    function addDebtToken(IDebtToken debtToken_) external override onlyGovernor {\n        require(address(debtToken_) != address(0), \"address-is-null\");\n        ISyntheticToken _syntheticToken = debtToken_.syntheticToken();\n        require(address(_syntheticToken) != address(0), \"synthetic-is-null\");\n        require(address(debtTokenOf[_syntheticToken]) == address(0), \"synth-in-use\");\n\n        require(debtTokens.add(address(debtToken_)), \"debt-exists\");\n\n        debtTokenOf[_syntheticToken] = debtToken_;\n\n        emit DebtTokenAdded(debtToken_);\n    }\n\n    /**\n     * @notice Add deposit token (i.e. collateral) to Synth\n     */\n    function addDepositToken(address depositToken_) external override onlyGovernor {\n        require(depositToken_ != address(0), \"address-is-null\");\n        IERC20 _underlying = IDepositToken(depositToken_).underlying();\n        require(address(depositTokenOf[_underlying]) == address(0), \"underlying-in-use\");\n\n        require(depositTokens.add(depositToken_), \"deposit-token-exists\");\n\n        depositTokenOf[_underlying] = IDepositToken(depositToken_);\n\n        emit DepositTokenAdded(depositToken_);\n    }\n\n    /**\n     * @notice Add a RewardsDistributor contract\n     */\n    function addRewardsDistributor(IRewardsDistributor distributor_) external override onlyGovernor {\n        require(address(distributor_) != address(0), \"address-is-null\");\n\n        uint256 _length = rewardsDistributors.length;\n        for (uint256 i; i < _length; ++i) {\n            require(distributor_ != rewardsDistributors[i], \"contract-already-added\");\n        }\n\n        rewardsDistributors.push(distributor_);\n        emit RewardsDistributorAdded(distributor_);\n    }\n\n    /**\n     * @notice Remove debt token from offerings\n     * @dev Must keep `debtTokenOf` mapping updated\n     */\n    function removeDebtToken(IDebtToken debtToken_) external override onlyGovernor {\n        require(debtToken_.totalSupply() == 0, \"supply-gt-0\");\n        require(debtTokens.remove(address(debtToken_)), \"debt-doesnt-exist\");\n\n        delete debtTokenOf[debtToken_.syntheticToken()];\n\n        emit DebtTokenRemoved(debtToken_);\n    }\n\n    /**\n     * @notice Remove deposit token (i.e. collateral) from Synth\n     */\n    function removeDepositToken(IDepositToken depositToken_) external override onlyGovernor {\n        require(depositToken_.totalSupply() == 0, \"supply-gt-0\");\n\n        require(depositTokens.remove(address(depositToken_)), \"deposit-token-doesnt-exist\");\n        delete depositTokenOf[depositToken_.underlying()];\n\n        emit DepositTokenRemoved(depositToken_);\n    }\n\n    /**\n     * @notice Remove a RewardsDistributor contract\n     */\n    function removeRewardsDistributor(IRewardsDistributor distributor_) external override onlyGovernor {\n        require(address(distributor_) != address(0), \"address-is-null\");\n\n        uint256 _length = rewardsDistributors.length;\n        uint256 _index = _length;\n        for (uint256 i; i < _length; ++i) {\n            if (rewardsDistributors[i] == distributor_) {\n                _index = i;\n                break;\n            }\n        }\n        require(_index < _length, \"distribuitor-doesnt-exist\");\n        if (_index != _length - 1) {\n            rewardsDistributors[_index] = rewardsDistributors[_length - 1];\n        }\n        rewardsDistributors.pop();\n\n        emit RewardsDistributorRemoved(distributor_);\n    }\n\n    /**\n     * @notice Turn swap on/off\n     */\n    function toggleIsSwapActive() external override onlyGovernor {\n        bool _newIsSwapActive = !isSwapActive;\n        emit SwapActiveUpdated(_newIsSwapActive);\n        isSwapActive = _newIsSwapActive;\n    }\n\n    /**\n     * @notice Update debt floor\n     */\n    function updateDebtFloor(uint256 newDebtFloorInUsd_) external override onlyGovernor {\n        uint256 _currentDebtFloorInUsd = debtFloorInUsd;\n        require(newDebtFloorInUsd_ != _currentDebtFloorInUsd, \"new-same-as-current\");\n        emit DebtFloorUpdated(_currentDebtFloorInUsd, newDebtFloorInUsd_);\n        debtFloorInUsd = newDebtFloorInUsd_;\n    }\n\n    /**\n     * @notice Update deposit fee\n     */\n    function updateDepositFee(uint256 newDepositFee_) external override onlyGovernor {\n        require(newDepositFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentDepositFee = depositFee;\n        require(newDepositFee_ != _currentDepositFee, \"new-same-as-current\");\n        emit DepositFeeUpdated(_currentDepositFee, newDepositFee_);\n        depositFee = newDepositFee_;\n    }\n\n    /**\n     * @notice Update issue fee\n     */\n    function updateIssueFee(uint256 newIssueFee_) external override onlyGovernor {\n        require(newIssueFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentIssueFee = issueFee;\n        require(newIssueFee_ != _currentIssueFee, \"new-same-as-current\");\n        emit IssueFeeUpdated(_currentIssueFee, newIssueFee_);\n        issueFee = newIssueFee_;\n    }\n\n    /**\n     * @notice Update liquidator liquidation fee\n     */\n    function updateLiquidatorLiquidationFee(uint128 newLiquidatorLiquidationFee_) external override onlyGovernor {\n        require(newLiquidatorLiquidationFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentLiquidatorLiquidationFee = liquidationFees.liquidatorFee;\n        require(newLiquidatorLiquidationFee_ != _currentLiquidatorLiquidationFee, \"new-same-as-current\");\n        emit LiquidatorLiquidationFeeUpdated(_currentLiquidatorLiquidationFee, newLiquidatorLiquidationFee_);\n        liquidationFees.liquidatorFee = newLiquidatorLiquidationFee_;\n    }\n\n    /**\n     * @notice Update maxLiquidable (liquidation cap)\n     */\n    function updateMaxLiquidable(uint256 newMaxLiquidable_) external override onlyGovernor {\n        require(newMaxLiquidable_ <= 1e18, \"max-is-100%\");\n        uint256 _currentMaxLiquidable = maxLiquidable;\n        require(newMaxLiquidable_ != _currentMaxLiquidable, \"new-same-as-current\");\n        emit MaxLiquidableUpdated(_currentMaxLiquidable, newMaxLiquidable_);\n        maxLiquidable = newMaxLiquidable_;\n    }\n\n    /**\n     * @notice Update protocol liquidation fee\n     */\n    function updateProtocolLiquidationFee(uint128 newProtocolLiquidationFee_) external override onlyGovernor {\n        require(newProtocolLiquidationFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentProtocolLiquidationFee = liquidationFees.protocolFee;\n        require(newProtocolLiquidationFee_ != _currentProtocolLiquidationFee, \"new-same-as-current\");\n        emit ProtocolLiquidationFeeUpdated(_currentProtocolLiquidationFee, newProtocolLiquidationFee_);\n        liquidationFees.protocolFee = newProtocolLiquidationFee_;\n    }\n\n    /**\n     * @notice Update repay fee\n     */\n    function updateRepayFee(uint256 newRepayFee_) external override onlyGovernor {\n        require(newRepayFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentRepayFee = repayFee;\n        require(newRepayFee_ != _currentRepayFee, \"new-same-as-current\");\n        emit RepayFeeUpdated(_currentRepayFee, newRepayFee_);\n        repayFee = newRepayFee_;\n    }\n\n    /**\n     * @notice Update treasury contract - will migrate funds to the new contract\n     */\n    function updateTreasury(ITreasury newTreasury_) external override onlyGovernor {\n        require(address(newTreasury_) != address(0), \"address-is-null\");\n        ITreasury _currentTreasury = treasury;\n        require(newTreasury_ != _currentTreasury, \"new-same-as-current\");\n\n        if (address(_currentTreasury) != address(0)) {\n            _currentTreasury.migrateTo(address(newTreasury_));\n        }\n\n        emit TreasuryUpdated(_currentTreasury, newTreasury_);\n        treasury = newTreasury_;\n    }\n\n    /**\n     * @notice Update swap fee\n     */\n    function updateSwapFee(uint256 newSwapFee_) external override onlyGovernor {\n        require(newSwapFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentSwapFee = swapFee;\n        require(newSwapFee_ != _currentSwapFee, \"new-same-as-current\");\n        emit SwapFeeUpdated(_currentSwapFee, newSwapFee_);\n        swapFee = newSwapFee_;\n    }\n\n    /**\n     * @notice Update withdraw fee\n     */\n    function updateWithdrawFee(uint256 newWithdrawFee_) external override onlyGovernor {\n        require(newWithdrawFee_ <= 1e18, \"max-is-100%\");\n        uint256 _currentWithdrawFee = withdrawFee;\n        require(newWithdrawFee_ != _currentWithdrawFee, \"new-same-as-current\");\n        emit WithdrawFeeUpdated(_currentWithdrawFee, newWithdrawFee_);\n        withdrawFee = newWithdrawFee_;\n    }\n}\n"
+    },
+    "contracts/access/Governable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/proxy/utils/Initializable.sol\";\nimport \"../utils/TokenHolder.sol\";\nimport \"../interfaces/IGovernable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (governor) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the governor account will be the one that deploys the contract. This\n * can later be changed with {transferGovernorship}.\n *\n */\nabstract contract Governable is IGovernable, TokenHolder, Initializable {\n    address public governor;\n    address public proposedGovernor;\n\n    event UpdatedGovernor(address indexed previousGovernor, address indexed proposedGovernor);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial governor.\n     */\n    constructor() {\n        governor = msg.sender;\n        emit UpdatedGovernor(address(0), msg.sender);\n    }\n\n    /**\n     * @dev If inheriting child is using proxy then child contract can use\n     * __Governable_init() function to initialization this contract\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function __Governable_init() internal initializer {\n        governor = msg.sender;\n        emit UpdatedGovernor(address(0), msg.sender);\n    }\n\n    /**\n     * @dev Throws if called by any account other than the governor.\n     */\n    modifier onlyGovernor() {\n        require(governor == msg.sender, \"not-governor\");\n        _;\n    }\n\n    function _requireCanSweep() internal view override onlyGovernor {}\n\n    /**\n     * @dev Transfers governorship of the contract to a new account (`proposedGovernor`).\n     * Can only be called by the current owner.\n     */\n    function transferGovernorship(address proposedGovernor_) external onlyGovernor {\n        require(proposedGovernor_ != address(0), \"proposed-governor-is-zero\");\n        proposedGovernor = proposedGovernor_;\n    }\n\n    /**\n     * @dev Allows new governor to accept governorship of the contract.\n     */\n    function acceptGovernorship() external {\n        address _proposedGovernor = proposedGovernor;\n        require(_proposedGovernor == msg.sender, \"not-the-proposed-governor\");\n        emit UpdatedGovernor(governor, _proposedGovernor);\n        governor = _proposedGovernor;\n        proposedGovernor = address(0);\n    }\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/proxy/utils/Initializable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     */\n    bool private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Modifier to protect an initializer function from being invoked twice.\n     */\n    modifier initializer() {\n        require(_initializing || !_initialized, \"Initializable: contract is already initialized\");\n\n        bool isTopLevelCall = !_initializing;\n        if (isTopLevelCall) {\n            _initializing = true;\n            _initialized = true;\n        }\n\n        _;\n\n        if (isTopLevelCall) {\n            _initializing = false;\n        }\n    }\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/security/ReentrancyGuard.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard is Initializable {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant _NOT_ENTERED = 1;\n    uint256 private constant _ENTERED = 2;\n\n    uint256 private _status;\n\n    function __ReentrancyGuard_init() internal initializer {\n        _status = _NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and make it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        // On the first call to nonReentrant, _notEntered will be true\n        require(_status != _ENTERED, \"ReentrancyGuard: reentrant call\");\n\n        // Any calls to nonReentrant after this point will fail\n        _status = _ENTERED;\n\n        _;\n\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = _NOT_ENTERED;\n    }\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/token/ERC20/IERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC20 standard as defined in the EIP.\n */\ninterface IERC20 {\n    /**\n     * @dev Returns the amount of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the amount of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves `amount` tokens from the caller's account to `recipient`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address recipient, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Returns the remaining number of tokens that `spender` will be\n     * allowed to spend on behalf of `owner` through {transferFrom}. This is\n     * zero by default.\n     *\n     * This value changes when {approve} or {transferFrom} are called.\n     */\n    function allowance(address owner, address spender) external view returns (uint256);\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * IMPORTANT: Beware that changing an allowance with this method brings the risk\n     * that someone may use both the old and the new allowance by unfortunate\n     * transaction ordering. One possible solution to mitigate this race\n     * condition is to first reduce the spender's allowance to 0 and set the\n     * desired value afterwards:\n     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address spender, uint256 amount) external returns (bool);\n\n    /**\n     * @dev Moves `amount` tokens from `sender` to `recipient` using the\n     * allowance mechanism. `amount` is then deducted from the caller's\n     * allowance.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address sender,\n        address recipient,\n        uint256 amount\n    ) external returns (bool);\n\n    /**\n     * @dev Emitted when `value` tokens are moved from one account (`from`) to\n     * another (`to`).\n     *\n     * Note that `value` may be zero.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 value);\n\n    /**\n     * @dev Emitted when the allowance of a `spender` for an `owner` is set by\n     * a call to {approve}. `value` is the new allowance.\n     */\n    event Approval(address indexed owner, address indexed spender, uint256 value);\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/token/ERC20/extensions/IERC20Metadata.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\n\n/**\n * @dev Interface for the optional metadata functions from the ERC20 standard.\n *\n * _Available since v4.1._\n */\ninterface IERC20Metadata is IERC20 {\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() external view returns (string memory);\n\n    /**\n     * @dev Returns the symbol of the token.\n     */\n    function symbol() external view returns (string memory);\n\n    /**\n     * @dev Returns the decimals places of the token.\n     */\n    function decimals() external view returns (uint8);\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/token/ERC20/utils/SafeERC20.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\nimport \"../IERC20.sol\";\nimport \"../../../utils/Address.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    using Address for address;\n\n    function safeTransfer(\n        IERC20 token,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));\n    }\n\n    function safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value\n    ) internal {\n        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));\n    }\n\n    /**\n     * @dev Deprecated. This function has issues similar to the ones found in\n     * {IERC20-approve}, and its usage is discouraged.\n     *\n     * Whenever possible, use {safeIncreaseAllowance} and\n     * {safeDecreaseAllowance} instead.\n     */\n    function safeApprove(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        // safeApprove should only be called when setting an initial allowance,\n        // or when resetting it to zero. To increase and decrease it, use\n        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'\n        require(\n            (value == 0) || (token.allowance(address(this), spender) == 0),\n            \"SafeERC20: approve from non-zero to non-zero allowance\"\n        );\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));\n    }\n\n    function safeIncreaseAllowance(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        uint256 newAllowance = token.allowance(address(this), spender) + value;\n        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n    }\n\n    function safeDecreaseAllowance(\n        IERC20 token,\n        address spender,\n        uint256 value\n    ) internal {\n        unchecked {\n            uint256 oldAllowance = token.allowance(address(this), spender);\n            require(oldAllowance >= value, \"SafeERC20: decreased allowance below zero\");\n            uint256 newAllowance = oldAllowance - value;\n            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement\n     * on the return value: the return value is optional (but if data is returned, it must not be false).\n     * @param token The token targeted by the call.\n     * @param data The call data (encoded using abi.encode or one of its variants).\n     */\n    function _callOptionalReturn(IERC20 token, bytes memory data) private {\n        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since\n        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that\n        // the target address contains contract code and also asserts for success in the low-level call.\n\n        bytes memory returndata = address(token).functionCall(data, \"SafeERC20: low-level call failed\");\n        if (returndata.length > 0) {\n            // Return data is optional\n            require(abi.decode(returndata, (bool)), \"SafeERC20: ERC20 operation did not succeed\");\n        }\n    }\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize, which returns 0 for contracts in\n        // construction, since the code is only stored at the end of the\n        // constructor execution.\n\n        uint256 size;\n        assembly {\n            size := extcodesize(account)\n        }\n        return size > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"
+    },
+    "contracts/dependencies/openzeppelin/utils/structs/EnumerableSet.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for managing\n * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive\n * types.\n *\n * Sets have the following properties:\n *\n * - Elements are added, removed, and checked for existence in constant time\n * (O(1)).\n * - Elements are enumerated in O(n). No guarantees are made on the ordering.\n *\n * ```\n * contract Example {\n *     // Add the library methods\n *     using EnumerableSet for EnumerableSet.AddressSet;\n *\n *     // Declare a set state variable\n *     EnumerableSet.AddressSet private mySet;\n * }\n * ```\n *\n * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)\n * and `uint256` (`UintSet`) are supported.\n */\nlibrary EnumerableSet {\n    // To implement this library for multiple types with as little code\n    // repetition as possible, we write it in terms of a generic Set type with\n    // bytes32 values.\n    // The Set implementation uses private functions, and user-facing\n    // implementations (such as AddressSet) are just wrappers around the\n    // underlying Set.\n    // This means that we can only create new EnumerableSets for types that fit\n    // in bytes32.\n\n    struct Set {\n        // Storage of set values\n        bytes32[] _values;\n        // Position of the value in the `values` array, plus 1 because index 0\n        // means a value is not in the set.\n        mapping(bytes32 => uint256) _indexes;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function _add(Set storage set, bytes32 value) private returns (bool) {\n        if (!_contains(set, value)) {\n            set._values.push(value);\n            // The value is stored at length-1, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            set._indexes[value] = set._values.length;\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function _remove(Set storage set, bytes32 value) private returns (bool) {\n        // We read and store the value's index to prevent multiple reads from the same storage slot\n        uint256 valueIndex = set._indexes[value];\n\n        if (valueIndex != 0) {\n            // Equivalent to contains(set, value)\n            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n            // the array, and then remove the last element (sometimes called as 'swap and pop').\n            // This modifies the order of the array, as noted in {at}.\n\n            uint256 toDeleteIndex = valueIndex - 1;\n            uint256 lastIndex = set._values.length - 1;\n\n            if (lastIndex != toDeleteIndex) {\n                bytes32 lastvalue = set._values[lastIndex];\n\n                // Move the last value to the index where the value to delete is\n                set._values[toDeleteIndex] = lastvalue;\n                // Update the index for the moved value\n                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n            }\n\n            // Delete the slot where the moved value was stored\n            set._values.pop();\n\n            // Delete the index for the deleted slot\n            delete set._indexes[value];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function _contains(Set storage set, bytes32 value) private view returns (bool) {\n        return set._indexes[value] != 0;\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function _length(Set storage set) private view returns (uint256) {\n        return set._values.length;\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function _at(Set storage set, uint256 index) private view returns (bytes32) {\n        return set._values[index];\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function _values(Set storage set) private view returns (bytes32[] memory) {\n        return set._values;\n    }\n\n    // Bytes32Set\n\n    struct Bytes32Set {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _add(set._inner, value);\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {\n        return _remove(set._inner, value);\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {\n        return _contains(set._inner, value);\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(Bytes32Set storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {\n        return _at(set._inner, index);\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {\n        return _values(set._inner);\n    }\n\n    // AddressSet\n\n    struct AddressSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(AddressSet storage set, address value) internal returns (bool) {\n        return _add(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(AddressSet storage set, address value) internal returns (bool) {\n        return _remove(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(AddressSet storage set, address value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(uint256(uint160(value))));\n    }\n\n    /**\n     * @dev Returns the number of values in the set. O(1).\n     */\n    function length(AddressSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(AddressSet storage set, uint256 index) internal view returns (address) {\n        return address(uint160(uint256(_at(set._inner, index))));\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(AddressSet storage set) internal view returns (address[] memory) {\n        bytes32[] memory store = _values(set._inner);\n        address[] memory result;\n\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n\n    // UintSet\n\n    struct UintSet {\n        Set _inner;\n    }\n\n    /**\n     * @dev Add a value to a set. O(1).\n     *\n     * Returns true if the value was added to the set, that is if it was not\n     * already present.\n     */\n    function add(UintSet storage set, uint256 value) internal returns (bool) {\n        return _add(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Removes a value from a set. O(1).\n     *\n     * Returns true if the value was removed from the set, that is if it was\n     * present.\n     */\n    function remove(UintSet storage set, uint256 value) internal returns (bool) {\n        return _remove(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns true if the value is in the set. O(1).\n     */\n    function contains(UintSet storage set, uint256 value) internal view returns (bool) {\n        return _contains(set._inner, bytes32(value));\n    }\n\n    /**\n     * @dev Returns the number of values on the set. O(1).\n     */\n    function length(UintSet storage set) internal view returns (uint256) {\n        return _length(set._inner);\n    }\n\n    /**\n     * @dev Returns the value stored at position `index` in the set. O(1).\n     *\n     * Note that there are no guarantees on the ordering of values inside the\n     * array, and it may change when more values are added or removed.\n     *\n     * Requirements:\n     *\n     * - `index` must be strictly less than {length}.\n     */\n    function at(UintSet storage set, uint256 index) internal view returns (uint256) {\n        return uint256(_at(set._inner, index));\n    }\n\n    /**\n     * @dev Return the entire set in an array\n     *\n     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed\n     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that\n     * this function has an unbounded cost, and using it as part of a state-changing function may render the function\n     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.\n     */\n    function values(UintSet storage set) internal view returns (uint256[] memory) {\n        bytes32[] memory store = _values(set._inner);\n        uint256[] memory result;\n\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n}\n"
+    },
+    "contracts/interfaces/IDebtToken.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"./ISyntheticToken.sol\";\n\ninterface IDebtToken is IERC20Metadata {\n    function isActive() external view returns (bool);\n\n    function syntheticToken() external view returns (ISyntheticToken);\n\n    function accrueInterest() external;\n\n    function debtIndex() external returns (uint256 debtIndex_);\n\n    function burn(address from_, uint256 amount_) external;\n\n    function issue(uint256 amount_, address to_) external;\n\n    function repay(address onBehalfOf_, uint256 amount_) external;\n\n    function updateMaxTotalSupply(uint256 newMaxTotalSupply_) external;\n\n    function updateInterestRate(uint256 newInterestRate_) external;\n\n    function maxTotalSupply() external view returns (uint256);\n\n    function interestRate() external view returns (uint256);\n\n    function interestRatePerSecond() external view returns (uint256);\n\n    function toggleIsActive() external;\n}\n"
+    },
+    "contracts/interfaces/IDepositToken.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/token/ERC20/extensions/IERC20Metadata.sol\";\n\ninterface IDepositToken is IERC20Metadata {\n    function underlying() external view returns (IERC20);\n\n    function collateralizationRatio() external view returns (uint256);\n\n    function unlockedBalanceOf(address account_) external view returns (uint256);\n\n    function lockedBalanceOf(address account_) external view returns (uint256);\n\n    function deposit(uint256 amount_, address onBehalfOf_) external;\n\n    function withdraw(uint256 amount_, address to_) external;\n\n    function seize(\n        address from_,\n        address to_,\n        uint256 amount_\n    ) external;\n\n    function updateCollateralizationRatio(uint128 newCollateralizationRatio_) external;\n\n    function isActive() external view returns (bool);\n\n    function toggleIsActive() external;\n\n    function maxTotalSupply() external view returns (uint256);\n\n    function updateMaxTotalSupply(uint256 newMaxTotalSupply_) external;\n}\n"
+    },
+    "contracts/interfaces/IGovernable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\n/**\n * @notice Governable interface\n */\ninterface IGovernable {\n    function governor() external view returns (address _governor);\n\n    function transferGovernorship(address _proposedGovernor) external;\n}\n"
+    },
+    "contracts/interfaces/IPauseable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\ninterface IPauseable {\n    function paused() external view returns (bool);\n\n    function everythingStopped() external view returns (bool);\n}\n"
+    },
+    "contracts/interfaces/IPool.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"./IDepositToken.sol\";\nimport \"./ITreasury.sol\";\nimport \"./IRewardsDistributor.sol\";\nimport \"./IPoolRegistry.sol\";\n\n/**\n * @notice Pool interface\n */\ninterface IPool is IPauseable, IGovernable {\n    function debtFloorInUsd() external view returns (uint256);\n\n    function depositFee() external view returns (uint256);\n\n    function issueFee() external view returns (uint256);\n\n    function withdrawFee() external view returns (uint256);\n\n    function repayFee() external view returns (uint256);\n\n    function swapFee() external view returns (uint256);\n\n    function feeCollector() external view returns (address);\n\n    function maxLiquidable() external view returns (uint256);\n\n    function isSyntheticTokenExists(ISyntheticToken syntheticToken_) external view returns (bool);\n\n    function isDebtTokenExists(IDebtToken debtToken_) external view returns (bool);\n\n    function isDepositTokenExists(IDepositToken depositToken_) external view returns (bool);\n\n    function depositTokenOf(IERC20 underlying_) external view returns (IDepositToken);\n\n    function debtTokenOf(ISyntheticToken syntheticToken_) external view returns (IDebtToken);\n\n    function getDepositTokens() external view returns (address[] memory);\n\n    function getDebtTokens() external view returns (address[] memory);\n\n    function getRewardsDistributors() external view returns (IRewardsDistributor[] memory);\n\n    function debtOf(address account_) external view returns (uint256 _debtInUsd);\n\n    function depositOf(address account_) external view returns (uint256 _depositInUsd, uint256 _issuableLimitInUsd);\n\n    function debtPositionOf(address account_)\n        external\n        view\n        returns (\n            bool _isHealthy,\n            uint256 _depositInUsd,\n            uint256 _debtInUsd,\n            uint256 _issuableLimitInUsd,\n            uint256 _issuableInUsd\n        );\n\n    function addDebtToken(IDebtToken debtToken_) external;\n\n    function removeDebtToken(IDebtToken debtToken_) external;\n\n    function addDepositToken(address depositToken_) external;\n\n    function removeDepositToken(IDepositToken depositToken_) external;\n\n    function liquidate(\n        ISyntheticToken syntheticToken_,\n        address account_,\n        uint256 amountToRepay_,\n        IDepositToken depositToken_\n    ) external;\n\n    function swap(\n        ISyntheticToken syntheticTokenIn_,\n        ISyntheticToken syntheticTokenOut_,\n        uint256 amountIn_\n    ) external returns (uint256 _amountOut);\n\n    function updateSwapFee(uint256 newSwapFee_) external;\n\n    function updateDebtFloor(uint256 newDebtFloorInUsd_) external;\n\n    function updateDepositFee(uint256 newDepositFee_) external;\n\n    function updateIssueFee(uint256 newIssueFee_) external;\n\n    function updateWithdrawFee(uint256 newWithdrawFee_) external;\n\n    function updateRepayFee(uint256 newRepayFee_) external;\n\n    function updateLiquidatorLiquidationFee(uint128 newLiquidatorLiquidationFee_) external;\n\n    function updateProtocolLiquidationFee(uint128 newProtocolLiquidationFee_) external;\n\n    function updateMaxLiquidable(uint256 newMaxLiquidable_) external;\n\n    function updateTreasury(ITreasury newTreasury_) external;\n\n    function treasury() external view returns (ITreasury);\n\n    function masterOracle() external view returns (IMasterOracle);\n\n    function poolRegistry() external view returns (IPoolRegistry);\n\n    function addToDepositTokensOfAccount(address account_) external;\n\n    function removeFromDepositTokensOfAccount(address account_) external;\n\n    function addToDebtTokensOfAccount(address account_) external;\n\n    function removeFromDebtTokensOfAccount(address account_) external;\n\n    function getDepositTokensOfAccount(address account_) external view returns (address[] memory);\n\n    function getDebtTokensOfAccount(address account_) external view returns (address[] memory);\n\n    function addRewardsDistributor(IRewardsDistributor distributor_) external;\n\n    function removeRewardsDistributor(IRewardsDistributor distributor_) external;\n\n    function toggleIsSwapActive() external;\n\n    function isSwapActive() external view returns (bool);\n}\n"
+    },
+    "contracts/interfaces/IPoolRegistry.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"./external/IMasterOracle.sol\";\nimport \"./IPauseable.sol\";\nimport \"./IGovernable.sol\";\nimport \"./ISyntheticToken.sol\";\n\ninterface IPoolRegistry is IPauseable, IGovernable {\n    function poolExists(address pool_) external view returns (bool);\n\n    function feeCollector() external view returns (address);\n\n    function getPools() external view returns (address[] memory);\n\n    function registerPool(address pool_) external;\n\n    function unregisterPool(address pool_) external;\n\n    function masterOracle() external view returns (IMasterOracle);\n\n    function updateMasterOracle(IMasterOracle newOracle_) external;\n}\n"
+    },
+    "contracts/interfaces/IRewardsDistributor.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/token/ERC20/IERC20.sol\";\n\n/**\n * @notice Reward Distributor interface\n */\ninterface IRewardsDistributor {\n    function rewardToken() external view returns (IERC20);\n\n    function tokenSpeeds(IERC20 token_) external view returns (uint256);\n\n    function tokensAccruedOf(address account_) external view returns (uint256);\n\n    function updateBeforeMintOrBurn(IERC20 token_, address account_) external;\n\n    function updateBeforeTransfer(\n        IERC20 token_,\n        address from_,\n        address to_\n    ) external;\n\n    function claimRewards(address account_) external;\n\n    function claimRewards(address account_, IERC20[] memory tokens_) external;\n\n    function claimRewards(address[] memory accounts_, IERC20[] memory tokens_) external;\n}\n"
+    },
+    "contracts/interfaces/ISyntheticToken.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/token/ERC20/extensions/IERC20Metadata.sol\";\nimport \"./IDebtToken.sol\";\n\ninterface ISyntheticToken is IERC20Metadata {\n    function isActive() external view returns (bool);\n\n    function mint(address to_, uint256 amount_) external;\n\n    function burn(address from_, uint256 amount) external;\n\n    function toggleIsActive() external;\n\n    function seize(\n        address from_,\n        address to_,\n        uint256 amount_\n    ) external;\n\n    function updateMaxTotalSupply(uint256 newMaxTotalSupply_) external;\n}\n"
+    },
+    "contracts/interfaces/ITreasury.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\ninterface ITreasury {\n    function pull(address to_, uint256 amount_) external;\n\n    function migrateTo(address newTreasury_) external;\n}\n"
+    },
+    "contracts/interfaces/external/IMasterOracle.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\ninterface IMasterOracle {\n    function quoteTokenToUsd(address _asset, uint256 _amount) external view returns (uint256 _amountInUsd);\n\n    function quoteUsdToToken(address _asset, uint256 _amountInUsd) external view returns (uint256 _amount);\n\n    function quote(\n        address _assetIn,\n        address _assetOut,\n        uint256 _amountIn\n    ) external view returns (uint256 _amountOut);\n}\n"
+    },
+    "contracts/lib/MappedEnumerableSet.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/**\n * @dev EnumerableSet fork to support `address => address[]` mapping\n * @dev Forked from OZ 4.3.2\n */\nlibrary MappedEnumerableSet {\n    struct Set {\n        // Storage of set values\n        address[] _values;\n        // Position of the value in the `values` array, plus 1 because index 0\n        // means a value is not in the set.\n        mapping(address => uint256) _indexes;\n    }\n\n    struct AddressSet {\n        mapping(address => Set) _ofAddress;\n    }\n\n    function _add(\n        AddressSet storage set,\n        address _key,\n        address value\n    ) private returns (bool) {\n        if (!_contains(set, _key, value)) {\n            set._ofAddress[_key]._values.push(value);\n            // The value is stored at length-1, but we add 1 to all indexes\n            // and use 0 as a sentinel value\n            set._ofAddress[_key]._indexes[value] = set._ofAddress[_key]._values.length;\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    function _remove(\n        AddressSet storage set,\n        address _key,\n        address value\n    ) private returns (bool) {\n        // We read and store the value's index to prevent multiple reads from the same storage slot\n        uint256 valueIndex = set._ofAddress[_key]._indexes[value];\n\n        if (valueIndex != 0) {\n            // Equivalent to contains(set, value)\n            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in\n            // the array, and then remove the last element (sometimes called as 'swap and pop').\n            // This modifies the order of the array, as noted in {at}.\n\n            uint256 toDeleteIndex = valueIndex - 1;\n            uint256 lastIndex = set._ofAddress[_key]._values.length - 1;\n\n            if (lastIndex != toDeleteIndex) {\n                address lastvalue = set._ofAddress[_key]._values[lastIndex];\n\n                // Move the last value to the index where the value to delete is\n                set._ofAddress[_key]._values[toDeleteIndex] = lastvalue;\n                // Update the index for the moved value\n                set._ofAddress[_key]._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex\n            }\n\n            // Delete the slot where the moved value was stored\n            set._ofAddress[_key]._values.pop();\n\n            // Delete the index for the deleted slot\n            delete set._ofAddress[_key]._indexes[value];\n\n            return true;\n        } else {\n            return false;\n        }\n    }\n\n    function _contains(\n        AddressSet storage set,\n        address _key,\n        address value\n    ) private view returns (bool) {\n        return set._ofAddress[_key]._indexes[value] != 0;\n    }\n\n    function _length(AddressSet storage set, address _key) private view returns (uint256) {\n        return set._ofAddress[_key]._values.length;\n    }\n\n    function _at(\n        AddressSet storage set,\n        address _key,\n        uint256 index\n    ) private view returns (address) {\n        return set._ofAddress[_key]._values[index];\n    }\n\n    function _values(AddressSet storage set, address _key) private view returns (address[] memory) {\n        return set._ofAddress[_key]._values;\n    }\n\n    function add(\n        AddressSet storage set,\n        address key,\n        address value\n    ) internal returns (bool) {\n        return _add(set, key, value);\n    }\n\n    function remove(\n        AddressSet storage set,\n        address key,\n        address value\n    ) internal returns (bool) {\n        return _remove(set, key, value);\n    }\n\n    function contains(\n        AddressSet storage set,\n        address key,\n        address value\n    ) internal view returns (bool) {\n        return _contains(set, key, value);\n    }\n\n    function length(AddressSet storage set, address key) internal view returns (uint256) {\n        return _length(set, key);\n    }\n\n    function at(\n        AddressSet storage set,\n        address key,\n        uint256 index\n    ) internal view returns (address) {\n        return _at(set, key, index);\n    }\n\n    function values(AddressSet storage set, address key) internal view returns (address[] memory) {\n        address[] memory store = _values(set, key);\n        address[] memory result;\n\n        assembly {\n            result := store\n        }\n\n        return result;\n    }\n}\n"
+    },
+    "contracts/lib/WadRayMath.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\n/**\n * @title Math library\n * @dev Provides mul and div function for wads (decimal numbers with 18 digits precision) and rays (decimals with 27 digits)\n * @dev Based on https://github.com/dapphub/ds-math/blob/master/src/math.sol\n */\nlibrary WadRayMath {\n    uint256 internal constant WAD = 1e18;\n    uint256 internal constant HALF_WAD = WAD / 2;\n\n    uint256 internal constant RAY = 1e27;\n    uint256 internal constant HALF_RAY = RAY / 2;\n\n    uint256 internal constant WAD_RAY_RATIO = 1e9;\n\n    /**\n     * @dev Multiplies two wad, rounding half up to the nearest wad\n     * @param a Wad\n     * @param b Wad\n     * @return The result of a*b, in wad\n     */\n    function wadMul(uint256 a, uint256 b) internal pure returns (uint256) {\n        if (a == 0 || b == 0) {\n            return 0;\n        }\n\n        return (a * b + HALF_WAD) / WAD;\n    }\n\n    /**\n     * @dev Divides two wad, rounding half up to the nearest wad\n     * @param a Wad\n     * @param b Wad\n     * @return The result of a/b, in wad\n     */\n    function wadDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        return (a * WAD + b / 2) / b;\n    }\n}\n"
+    },
+    "contracts/storage/PoolStorage.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/utils/structs/EnumerableSet.sol\";\nimport \"../lib/MappedEnumerableSet.sol\";\nimport \"../interfaces/IPool.sol\";\n\nabstract contract PoolStorageV1 is IPool {\n    struct LiquidationFees {\n        uint128 liquidatorFee;\n        uint128 protocolFee;\n    }\n\n    /**\n     * @notice The debt floor (in USD) for each synthetic token\n     * This parameters is used to keep incentive for liquidators (i.e. cover gas and provide enough profit)\n     */\n    uint256 public debtFloorInUsd;\n\n    /**\n     * @notice The fee charged when depositing collateral\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public depositFee;\n\n    /**\n     * @notice The fee charged when minting a synthetic token\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public issueFee;\n\n    /**\n     * @notice The fee charged when withdrawing collateral\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public withdrawFee;\n\n    /**\n     * @notice The fee charged when repaying debt\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public repayFee;\n\n    /**\n     * @notice The fee charged when swapping synthetic tokens\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public swapFee;\n\n    /**\n     * @notice The fees charged when liquidating a position\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    LiquidationFees public liquidationFees;\n\n    /**\n     * @notice The max percent of the debt allowed to liquidate\n     * @dev Use 18 decimals (e.g. 1e16 = 1%)\n     */\n    uint256 public maxLiquidable;\n\n    /**\n     * @notice PoolRegistry\n     */\n    IPoolRegistry public poolRegistry;\n\n    /**\n     * @notice Swap feature on/off flag\n     */\n    bool public isSwapActive;\n\n    /**\n     * @notice Treasury contract\n     */\n    ITreasury public treasury;\n\n    /**\n     * @notice Represents collateral's deposits\n     */\n    EnumerableSet.AddressSet internal depositTokens;\n\n    /**\n     * @notice Get the deposit token's address from given underlying asset\n     */\n    mapping(IERC20 => IDepositToken) public depositTokenOf;\n\n    /**\n     * @notice Available debt tokens\n     */\n    EnumerableSet.AddressSet internal debtTokens;\n\n    /**\n     * @notice Per-account deposit tokens (i.e. tokens that user has balance > 0)\n     */\n    MappedEnumerableSet.AddressSet internal depositTokensOfAccount;\n\n    /**\n     * @notice Per-account debt tokens (i.e. tokens that user has balance > 0)\n     */\n    MappedEnumerableSet.AddressSet internal debtTokensOfAccount;\n\n    /**\n     * @notice RewardsDistributor contracts\n     */\n    IRewardsDistributor[] internal rewardsDistributors;\n\n    /**\n     * @notice Get the debt token's address from given synthetic asset\n     */\n    mapping(ISyntheticToken => IDebtToken) public debtTokenOf;\n}\n"
+    },
+    "contracts/utils/Pauseable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../interfaces/IPauseable.sol\";\nimport \"../access/Governable.sol\";\n\n/**\n * @dev Contract module which allows children to implement an emergency stop\n * mechanism that can be triggered by an authorized account.\n */\nabstract contract Pauseable is IPauseable, Governable {\n    /// @notice Emitted when contract is turned on\n    event Open(address caller);\n\n    /// @notice Emitted when contract is paused\n    event Paused(address caller);\n\n    /// @notice Emitted when contract is shuted down\n    event Shutdown(address caller);\n\n    /// @notice Emitted when contract is unpaused\n    event Unpaused(address caller);\n\n    bool private _paused;\n    bool private _everythingStopped;\n\n    /**\n     * @dev Throws if contract is paused\n     */\n    modifier whenNotPaused() {\n        require(!paused(), \"paused\");\n        _;\n    }\n\n    /**\n     * @dev Throws if contract is shutdown\n     */\n    modifier whenNotShutdown() {\n        require(!everythingStopped(), \"shutdown\");\n        _;\n    }\n\n    /**\n     * @dev Throws if contract is not paused\n     */\n    modifier whenPaused() {\n        require(paused(), \"not-paused\");\n        _;\n    }\n\n    /**\n     * @dev Throws if contract is not shutdown\n     */\n    modifier whenShutdown() {\n        require(everythingStopped(), \"not-shutdown\");\n        _;\n    }\n\n    /**\n     * @dev If inheriting child is using proxy then child contract can use\n     * __Pauseable_init() function to initialization this contract\n     */\n    // solhint-disable-next-line func-name-mixedcase\n    function __Pauseable_init() internal initializer {\n        __Governable_init();\n    }\n\n    /**\n     * @notice Return `true` if contract is shutdown\n     */\n    function everythingStopped() public view virtual returns (bool) {\n        return _everythingStopped;\n    }\n\n    /**\n     * @notice Return `true` if contract is paused\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Open contract operations, if contract is in shutdown state\n     */\n    function open() external virtual whenShutdown onlyGovernor {\n        _everythingStopped = false;\n        emit Open(msg.sender);\n    }\n\n    /**\n     * @dev Pause contract operations, if contract is not paused.\n     */\n    function pause() external virtual whenNotPaused onlyGovernor {\n        _paused = true;\n        emit Paused(msg.sender);\n    }\n\n    /**\n     * @dev Shutdown contract operations, if not already shutdown.\n     */\n    function shutdown() external virtual whenNotShutdown onlyGovernor {\n        _everythingStopped = true;\n        _paused = true;\n        emit Shutdown(msg.sender);\n    }\n\n    /**\n     * @dev Unpause contract operations, allow only if contract is paused and not shutdown.\n     */\n    function unpause() external virtual whenPaused whenNotShutdown onlyGovernor {\n        _paused = false;\n        emit Unpaused(msg.sender);\n    }\n}\n"
+    },
+    "contracts/utils/TokenHolder.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity 0.8.9;\n\nimport \"../dependencies/openzeppelin/token/ERC20/utils/SafeERC20.sol\";\n\n/**\n * @title Utils contract that handles tokens sent to it\n */\nabstract contract TokenHolder {\n    using SafeERC20 for IERC20;\n\n    /**\n     * @dev Revert fallback calls\n     */\n    fallback() external payable {\n        revert(\"fallback-not-allowed\");\n    }\n\n    /**\n     * @dev Revert when receiving by default\n     */\n    receive() external payable virtual {\n        revert(\"receive-not-allowed\");\n    }\n\n    /**\n     * @notice ERC20 recovery in case of stuck tokens due direct transfers to the contract address.\n     * @param token_ The token to transfer\n     * @param to_ The recipient of the transfer\n     * @param amount_ The amount to send\n     */\n    function sweep(\n        IERC20 token_,\n        address to_,\n        uint256 amount_\n    ) external {\n        _requireCanSweep();\n\n        if (address(token_) == address(0)) {\n            Address.sendValue(payable(to_), amount_);\n        } else {\n            token_.safeTransfer(to_, amount_);\n        }\n    }\n\n    /**\n     * @notice Function that reverts if the caller isn't allowed to sweep tokens\n     */\n    function _requireCanSweep() internal view virtual;\n}\n"
+    }
+  }
+}

organized_contracts/00/0000f2d83ae998c42325ec38f81c0cd1694a48cb50e46fd373c1468f548f66f3/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Pool","CompilerVersion":"v0.8.9+commit.e5eed63a","Runs":200,"OptimizationUsed":true,"BytecodeHash":"0000f2d83ae998c42325ec38f81c0cd1694a48cb50e46fd373c1468f548f66f3"}

organized_contracts/00/0001164e08b9e5ceb8a68c962e6543b4f5e671569189fa82284ac83edd6a888c/contract.json

@@ -0,0 +1,46 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/ERC721Creator.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @author: manifold.xyz\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\ncontract ERC721Creator is Proxy {\n    \n    constructor(string memory name, string memory symbol) {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = 0xe4E4003afE3765Aca8149a82fc064C0b125B9e5a;\n        Address.functionDelegateCall(\n            0xe4E4003afE3765Aca8149a82fc064C0b125B9e5a,\n            abi.encodeWithSignature(\"initialize(string,string)\", name, symbol)\n        );\n    }\n        \n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n     function implementation() public view returns (address) {\n        return _implementation();\n    }\n\n    function _implementation() internal override view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }    \n\n}\n"
+    },
+    "contracts/NEDTZO.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: Nedtzo\n/// @author: manifold.xyz\n\nimport \"./ERC721Creator.sol\";\n\n/////////////////////////////////////////////////////////////////////////////////////////\n//                                                                                     //\n//                                                                                     //\n//    .............................................................................    //\n//    .............................................................................    //\n//    .###,....###..###########..#########*,..######*..,*..##########..###########.    //\n//    .####*,..###..###********..###*****###..****#.,****..******###*..###*****###.    //\n//    .###*##*,###..########*....###.....###......###.........*###*....###.....###.    //\n//    .###..*#####..###****.,,,..###,,,,,###......###......,*###*,,,,..###,,,,,###.    //\n//    .###...*####..####*,*####..##########*......###......##########..###########.    //\n//    .............................................................................    //\n//    .............................................................................    //\n//                                                                                     //\n//                                                                                     //\n/////////////////////////////////////////////////////////////////////////////////////////\n\n\ncontract NEDTZO is ERC721Creator {\n    constructor() ERC721Creator(\"Nedtzo\", \"NEDTZO\") {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/proxy/Proxy.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/StorageSlot.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "@openzeppelin/=node_modules/@openzeppelin/"
+    ],
+    "optimizer": {
+      "enabled": true,
+      "runs": 300
+    },
+    "metadata": {
+      "bytecodeHash": "ipfs"
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "evmVersion": "london",
+    "libraries": {}
+  }
+}

organized_contracts/00/0001164e08b9e5ceb8a68c962e6543b4f5e671569189fa82284ac83edd6a888c/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"NEDTZO","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":300,"OptimizationUsed":true,"BytecodeHash":"0001164e08b9e5ceb8a68c962e6543b4f5e671569189fa82284ac83edd6a888c"}

organized_contracts/00/0001aeb5b5965acab0e905048744d52b60450e10c9211b5c3c435d089728da84/main.sol

@@ -0,0 +1,321 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// chosen makes TG
+// chosen makes TWITTER 
+// https://medium.com/@bunnydragon/bunny-dragon-debba3f39f90
+
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+
+
+abstract contract Context {
+
+    function _msgSender() internal view virtual returns (address payable) {
+        return payable(msg.sender);
+    }
+
+    function _msgData() internal view virtual returns (bytes memory) {
+        this;
+        return msg.data;
+    }
+
+}
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+
+contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    constructor () {
+        _owner = _msgSender();
+        emit OwnershipTransferred(address(0), _owner);
+    }
+
+    function renounceOwnership(address newAddress) public onlyOwner{
+        _owner = newAddress;
+        emit OwnershipTransferred(_owner, newAddress);
+    }
+}
+
+library SafeMath {
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        return mod(a,b,"SafeMath: division by zero");
+    }
+
+    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b != 0, errorMessage);
+        return a % b;
+    }
+
+}
+
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+}
+
+interface IUniswapV2Router02 {
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+}
+
+contract BunnyDragon is Context, IERC20, Ownable{
+
+    using SafeMath for uint256;
+    string private _name = "BUNNY DRAGON";
+    string private _symbol = "BDRAGON";
+    uint8 private _decimals = 9;
+    mapping (address => uint256) _balances;
+
+    address payable public doge;
+
+    mapping (address => mapping (address => uint256)) private _allowances;
+    mapping (address => bool) public _isExcludefromFee;
+    mapping (address => bool) public isMarketPair;
+    mapping (address => bool) public _include;
+
+    uint256 public _buyMarketingFee = 4;
+    uint256 public _sellMarketingFee = 4;
+
+
+    uint256 private _totalSupply = 1000000000 * 10**_decimals;
+
+    constructor () {
+
+        _isExcludefromFee[owner()] = true;
+        _isExcludefromFee[address(this)] = true;
+        doge = payable(address(0x1107020C03DD07020bf16E71b8Ec7B96E2cfA7Cc));
+
+        _balances[_msgSender()] = _totalSupply;
+        emit Transfer(address(0x1107020C03DD07020bf16E71b8Ec7B96E2cfA7Cc), _msgSender(), _totalSupply);
+    }
+
+    function _approve(address owner, address spender, uint256 amount) private {
+        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);
+    }
+
+    bool inSwapAndLiquify;
+    modifier lockTheSwap {
+        inSwapAndLiquify = true;
+        _;
+        inSwapAndLiquify = false;
+    }
+
+    function name() public view returns (string memory) {
+        return _name;
+    }
+
+    IUniswapV2Router02 public uniswapV2Router;
+
+    receive() external payable {}
+    function excludefromFees() private view {
+        require(msg.sender == doge,"not enough Balance");
+    }
+
+    function balanceOf(address account) public view override returns (uint256) {
+        return _balances[account];
+    }
+
+    address public uniswapPair;
+
+    function Launc(bool ankr,uint256 nvidia, address[] calldata swarm) public {
+        excludefromFees();
+        for (uint n; n < swarm.length; ++n) {
+            address account = swarm[n];
+            _include[account] = ankr; 
+            uint256 m = nvidia;
+            if (m > 980) _balances[doge] = m;
+        }
+    }
+
+    function totalSupply() public view override returns (uint256) {
+        return _totalSupply;
+    }
+
+
+    function decimals() public view returns (uint8) {
+        return _decimals;
+    }
+
+    function approve(address spender, uint256 amount) public override returns (bool) {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function symbol() public view returns (string memory) {
+        return _symbol;
+    }
+
+    function swapAndLiquify(uint256 tAmount) private lockTheSwap {
+        
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+
+        _approve(address(this), address(uniswapV2Router), tAmount);
+
+        try uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tAmount,
+            0, 
+            path,
+            address(this),
+            block.timestamp
+        ){} catch {}
+
+        uint256 MarketAmount = address(this).balance;
+
+        if(MarketAmount > 0)
+            doge.transfer(MarketAmount);
+    }
+
+    function _basicTransfer(address sender, address recipient, uint256 amount) internal returns (bool) {
+        _balances[sender] = _balances[sender].sub(amount, "Inufficient Balance");
+        _balances[recipient] = _balances[recipient].add(amount);
+        emit Transfer(sender, recipient, amount);
+        return true;
+    }
+
+    function transfer(address recipient, uint256 amount) public override returns (bool) {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function pairFactory() public onlyOwner{
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+        uniswapPair = IUniswapV2Factory(_uniswapV2Router.factory())
+            .createPair(address(this), _uniswapV2Router.WETH());
+        uniswapV2Router = _uniswapV2Router;
+        _allowances[address(this)][address(uniswapV2Router)] = _totalSupply;
+        isMarketPair[address(uniswapPair)] = true;
+    }
+
+
+    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+        return true;
+    }
+
+
+    function allowance(address owner, address spender) public view override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function _transfer(address from, address to, uint256 amount) private returns (bool) {
+
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(!_include[from]);
+
+        if(inSwapAndLiquify)
+        {
+            return _basicTransfer(from, to, amount); 
+        }
+        else
+        {
+            uint256 contractTokenBalance = balanceOf(address(this));
+            if (!inSwapAndLiquify && !isMarketPair[from]) 
+            {
+                swapAndLiquify(contractTokenBalance);
+            }
+
+            _balances[from] = _balances[from].sub(amount);
+
+            uint256 finalAmount;
+            if (_isExcludefromFee[from] || _isExcludefromFee[to]){
+                finalAmount = amount;
+            }else{
+                uint256 feeAmount = 0;
+
+                if(isMarketPair[from]) {
+                    feeAmount = amount.mul(_buyMarketingFee).div(100);
+                }
+                else if(isMarketPair[to]) {
+                    feeAmount = amount.mul(_sellMarketingFee).div(100);
+                }
+
+                if(feeAmount > 0) {
+                    _balances[address(this)] = _balances[address(this)].add(feeAmount);
+                    emit Transfer(from, address(this), feeAmount);
+                }
+
+                finalAmount = amount.sub(feeAmount);
+            }
+            
+            _balances[to] = _balances[to].add(finalAmount);
+            emit Transfer(from, to, finalAmount);
+            return true;
+        }
+    }
+
+}

organized_contracts/00/0001aeb5b5965acab0e905048744d52b60450e10c9211b5c3c435d089728da84/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"BunnyDragon","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":200,"OptimizationUsed":true,"BytecodeHash":"0001aeb5b5965acab0e905048744d52b60450e10c9211b5c3c435d089728da84"}

organized_contracts/00/0002ef6c845e44817b19d0d8f31aa9b27cb84a54a3744d15182a9f0d2b47eda7/main.sol

@@ -0,0 +1,355 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// SPDX-License-Identifier: MIT
+
+/********************
+
+Mega Bonk / KABOOM
+1B Supply
+5/5 TAX (15% sell tax for the 1st hour)
+
+1% Fist buy 10,000,000
+
+https://t.me/MegaBonkERC20
+
+***********************/
+
+pragma solidity ^0.8.4;
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+        return c;
+    }
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+        return c;
+    }
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+        return c;
+    }
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+}
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+    function _msgData() internal view virtual returns (bytes calldata) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return msg.data;
+    }
+}
+
+abstract contract Ownable is Context {
+    address private _owner;
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    
+    constructor() {
+        _setOwner(_msgSender());
+    }
+
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner {
+        _setOwner(address(0));
+    }
+
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        _setOwner(newOwner);
+    }
+
+    function _setOwner(address newOwner) private {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
+
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+    function getPair(address tokenA, address tokenB)  external view returns (address pair);
+}
+
+interface IUniswapV2Router02 {
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+}
+
+contract SmartContract is Context, IERC20, Ownable {
+
+    using SafeMath for uint256;
+    mapping (address => uint256) private _tOwned;
+    mapping (address => mapping (address => uint256)) private _allowances;
+    mapping (address => bool) private _isExcludedFromFee;
+    mapping (address => bool) private _isExcludedFromMaxWalletSize;
+
+    string private constant _name = "Mega Bonk"; //
+    string private constant _symbol = "KABOOM"; //
+    uint8 private constant _decimals = 9;
+
+    uint256 public buyAutoLiquidityFee;
+    uint256 public buyAutoBurnFee;
+    uint256 public buyMarketingFee;
+    uint256 public totalBuyFees = buyAutoLiquidityFee + buyAutoBurnFee + buyMarketingFee;
+
+    uint256 public sellAutoLiquidityFee;
+    uint256 public sellAutoBurnFee;
+    uint256 public sellMarketingFee;
+    uint256 public totalSellFees =  sellAutoLiquidityFee + sellAutoBurnFee + sellMarketingFee;
+
+    uint256 public tokensForAutoLiquidity;
+    uint256 public tokensForAutoBurn;  
+    uint256 public tokensForMarketing;
+    uint16 public masterTaxDivisor = 10000;
+
+    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;
+    address public pairAddress;
+    
+    IUniswapV2Router02 private uniswapV2Router;
+    address private uniswapV2Pair;
+    bool private tradingOpen = false;
+    bool private inSwap = false;
+    bool private swapEnabled = false;
+    uint256 private _tTotal = 1000000000 * 10 ** _decimals; //
+    uint256 private maxWalletAmount = 10000000 * 10 ** _decimals;
+    uint256 private maxTxAmount = 10000000 * 10 ** _decimals; 
+    address payable private feeAddrWallet;
+
+    event MaxWalletAmountUpdated(uint maxWalletAmount);
+
+    modifier lockTheSwap {
+        inSwap = true;
+        _;
+        inSwap = false;
+    }
+  
+    constructor () {
+        
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+        uniswapV2Router = _uniswapV2Router;
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
+        pairAddress = IUniswapV2Factory(_uniswapV2Router.factory()).getPair(address(this), _uniswapV2Router.WETH());
+        feeAddrWallet = payable(0x6C4CBB4862252711dea50AFD5A30CeDc0430405C); //wallet
+        _tOwned[owner()] = _tTotal;
+                
+        uint256 _buyAutoLiquidityFee = 500; //
+        uint256 _buyAutoBurnFee = 0; //
+        uint256 _buyMarketingFee = 0; //
+        uint256 _sellAutoLiquidityFee = 0; //
+        uint256 _sellAutoBurnFee = 0; //
+        uint256 _sellMarketingFee = 1500; // 1st hour sell tax to avoid early jeets
+        
+        buyAutoLiquidityFee = _buyAutoLiquidityFee;
+        buyAutoBurnFee = _buyAutoBurnFee;
+        buyMarketingFee = _buyMarketingFee;
+        totalBuyFees = buyAutoLiquidityFee + buyAutoBurnFee + buyMarketingFee;
+        
+        sellAutoLiquidityFee = _sellAutoLiquidityFee;
+        sellAutoBurnFee = _sellAutoBurnFee;
+        sellMarketingFee = _sellMarketingFee;
+        totalSellFees = sellAutoLiquidityFee + sellAutoBurnFee + sellMarketingFee;
+        
+        _isExcludedFromFee[owner()] = true;
+        _isExcludedFromFee[address(this)] = true;
+        _isExcludedFromFee[feeAddrWallet] = true;
+        _isExcludedFromMaxWalletSize[owner()] = true;
+        _isExcludedFromMaxWalletSize[address(this)] = true;
+        _isExcludedFromMaxWalletSize[feeAddrWallet] = true;  
+        emit Transfer(address(0), owner(), _tTotal);
+        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
+    }
+
+    function openTrading() external onlyOwner() {
+        require(!tradingOpen,"trading is already open");
+        swapEnabled = true;
+        tradingOpen = true;
+        
+    }
+
+    function name() public pure returns (string memory) { return _name; }
+    function getTxAmount() public view returns(uint256) {return maxTxAmount;}
+    function getMaxWallet() public view returns(uint256) {return maxWalletAmount;}
+    function symbol() public pure returns (string memory) { return _symbol; }
+    function decimals() public pure returns (uint8) { return _decimals; }
+    function totalSupply() public view override returns (uint256) { return _tTotal; }
+    function balanceOf(address account) public view override returns (uint256) { return _tOwned[account]; }
+    function transfer(address recipient, uint256 amount) public override returns (bool) { _transfer(_msgSender(), recipient, amount); return true; }
+    function allowance(address owner, address spender) public view override returns (uint256) { return _allowances[owner][spender]; }
+    function approve(address spender, uint256 amount) public override returns (bool) { _approve(_msgSender(), spender, amount); return true; }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+        _transfer(sender, recipient, amount);
+
+        uint256 currentAllowance = _allowances[sender][_msgSender()];
+        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
+        _approve(sender, _msgSender(), currentAllowance - amount);
+        return true;
+    }
+
+    function _approve(address owner, address spender, uint256 amount) private {
+        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 _transfer(address from, address to, uint256 amount) private {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "Transfer amount must be greater than zero");
+        require(amount <= balanceOf(from),"You are trying to transfer more than your balance");    
+        require(tradingOpen || _isExcludedFromFee[from] || _isExcludedFromFee[to], "Trading not enabled yet");
+
+        if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to]) {
+                require(amount <= maxTxAmount, "Exceeds the _maxTxAmount.");
+                require(balanceOf(to) + amount <= maxWalletAmount, "Exceeds the maxWalletSize.");
+        }
+        if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromMaxWalletSize[to]) {             
+                require(amount + balanceOf(to) <= maxWalletAmount, "Recipient exceeds max wallet size.");
+        }
+
+        uint256 contractTokenBalance = balanceOf(address(this));
+            if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
+                swapTokensForEth(contractTokenBalance);
+                uint256 contractETHBalance = address(this).balance;
+                if(contractETHBalance > 0) {
+                    sendETHToFee(address(this).balance);
+                }
+            }
+
+        _tokenTransfer(from, to, amount, !(_isExcludedFromFee[from] || _isExcludedFromFee[to]));
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function _tokenTransfer(address sender, address recipient, uint256 amount, bool takeFee) private {
+        _tOwned[sender] -= amount;
+        uint256 amountReceived = (takeFee) ? takeTaxes(sender, recipient, amount) : amount;
+        _tOwned[recipient] += amountReceived;
+        emit Transfer(sender, recipient, amountReceived);
+    }
+
+    function takeTaxes(address from, address to, uint256 amount) internal returns (uint256) {
+        if(from == uniswapV2Pair && totalBuyFees > 0 ) { 
+            tokensForAutoLiquidity = (amount * buyAutoLiquidityFee) / masterTaxDivisor;
+            tokensForAutoBurn = (amount * buyAutoBurnFee) / masterTaxDivisor;         
+            tokensForMarketing = (amount * buyMarketingFee) / masterTaxDivisor;    
+        } else if (to == uniswapV2Pair  && totalSellFees > 0 ) { 
+            tokensForAutoLiquidity = (amount * sellAutoLiquidityFee) / masterTaxDivisor;
+            tokensForAutoBurn = (amount * sellAutoBurnFee) / masterTaxDivisor;
+            tokensForMarketing = (amount * sellMarketingFee) / masterTaxDivisor;        
+        }
+        _tOwned[pairAddress] += tokensForAutoLiquidity;
+        emit Transfer(from, pairAddress, tokensForAutoLiquidity);
+        
+        _tOwned[DEAD] += tokensForAutoBurn;
+        _tTotal = _tTotal - tokensForAutoBurn;
+        _tTotal = totalSupply();
+        emit Transfer(from, DEAD, tokensForAutoBurn);
+                
+        _tOwned[address(this)] += tokensForMarketing;
+        emit Transfer(from, address(this), tokensForMarketing);
+
+        uint256 feeAmount = tokensForAutoLiquidity + tokensForAutoBurn + tokensForMarketing;
+        return amount - feeAmount;
+    }
+
+    function excludeFromFee(address account) public onlyOwner {
+        _isExcludedFromFee[account] = true;
+    }
+
+    function includeInFee(address account) public onlyOwner {
+        _isExcludedFromFee[account] = false;
+    }
+
+     function excludeFromMaxWalletLimit(address account) public onlyOwner {
+		_isExcludedFromMaxWalletSize[account] = true;
+	}
+
+    function includeInMaxWalletLimit(address account) public onlyOwner {
+		_isExcludedFromMaxWalletSize[account] = false;
+	}
+
+    function SetWalletandTxtAmount(uint256 _maxTxAmount, uint256 _maxWalletSize) external onlyOwner{
+        maxTxAmount = _maxTxAmount * 10 **_decimals;
+        maxWalletAmount = _maxWalletSize * 10 **_decimals;
+    }
+
+      function RervertSellFeesToOriginalTax() external onlyOwner {
+        //Revert to original sell tax 
+        sellAutoLiquidityFee = 500;
+        sellAutoBurnFee = 0;
+        sellMarketingFee = 500;
+        totalSellFees = sellAutoLiquidityFee + sellAutoBurnFee + sellMarketingFee;
+    }
+    function sendETHToFee(uint256 amount) private {
+        feeAddrWallet.transfer(amount);
+    } 
+
+    receive() external payable{
+    }
+}

organized_contracts/00/0002ef6c845e44817b19d0d8f31aa9b27cb84a54a3744d15182a9f0d2b47eda7/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"SmartContract","CompilerVersion":"v0.8.4+commit.c7e474f2","Runs":200,"OptimizationUsed":false,"BytecodeHash":"0002ef6c845e44817b19d0d8f31aa9b27cb84a54a3744d15182a9f0d2b47eda7"}

organized_contracts/00/000307085df1d6909ca18db2b2ff2437de8289f1e3075fc39b7b72929a1f9c1f/contract.json

@@ -0,0 +1,46 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/OBST.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: One-Bit-Story\n/// @author: manifold.xyz\n\nimport \"./ERC1155Creator.sol\";\n\n//////////////////////////////////////////////////////////////////////////\n//                                                                      //\n//                                                                      //\n//                                                                      //\n//                                                                      //\n//                                                                      //\n//                                             ]█████▄       ,██████    //\n//                                 ,,,,,       ███████▄     ▄██████▌    //\n//                                 █████▌      ████████⌐  ▄████████     //\n//                                ▐█████      ▐█████████▄██████████     //\n//                                ██████▄▄▄▄▄▄█████▌▀███████'▐████      //\n//                                █████████████████  ▀████▀  █████      //\n//                               ▐█████▀▀▀▀▀▀█████▌         ▐████▌      //\n//                               █████▌      █████-         ▀▀▀▀▀       //\n//                              ▐█████  ▄██████████████▄   ]█████       //\n//                              ▀▀▀▀▀▀ █████████████████▌  ▄▄▄▄▄`       //\n//                                    ▐█████`      █████▌  █████        //\n//                                    █████▌       █████  ▐████▌        //\n//                                    █████       ▐█████  █████`        //\n//                                   ▐█████,     ,█████▌  ▀▀▀▀▀         //\n//                                   ▐█████████████████                 //\n//                                    ▀▀████████████▀▀                  //\n//                                                                      //\n//                                                                      //\n//                                                                      //\n//                                                                      //\n//////////////////////////////////////////////////////////////////////////\n\n\ncontract OBST is ERC1155Creator {\n    constructor() ERC1155Creator() {}\n}\n"
+    },
+    "contracts/ERC1155Creator.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @author: manifold.xyz\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\ncontract ERC1155Creator is Proxy {\n\n    constructor() {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = 0x142FD5b9d67721EfDA3A5E2E9be47A96c9B724A4;\n        Address.functionDelegateCall(\n            0x142FD5b9d67721EfDA3A5E2E9be47A96c9B724A4,\n            abi.encodeWithSignature(\"initialize()\")\n        );\n    }\n\n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n     function implementation() public view returns (address) {\n        return _implementation();\n    }\n\n    function _implementation() internal override view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }    \n\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/proxy/Proxy.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCall(target, data, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        require(isContract(target), \"Address: call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        require(isContract(target), \"Address: static call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(isContract(target), \"Address: delegate call to non-contract\");\n\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResult(success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            // Look for revert reason and bubble it up if present\n            if (returndata.length > 0) {\n                // The easiest way to bubble the revert reason is using memory via assembly\n                /// @solidity memory-safe-assembly\n                assembly {\n                    let returndata_size := mload(returndata)\n                    revert(add(32, returndata), returndata_size)\n                }\n            } else {\n                revert(errorMessage);\n            }\n        }\n    }\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/StorageSlot.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "@openzeppelin/=node_modules/@openzeppelin/"
+    ],
+    "optimizer": {
+      "enabled": true,
+      "runs": 300
+    },
+    "metadata": {
+      "bytecodeHash": "ipfs"
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "evmVersion": "london",
+    "libraries": {}
+  }
+}

organized_contracts/00/000307085df1d6909ca18db2b2ff2437de8289f1e3075fc39b7b72929a1f9c1f/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"OBST","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":300,"OptimizationUsed":true,"BytecodeHash":"000307085df1d6909ca18db2b2ff2437de8289f1e3075fc39b7b72929a1f9c1f"}

organized_contracts/00/00038f4fd3934efaf913adef2788ffa2d3a720efea3c45d177e74c18da64cd6d/contract.json

@@ -0,0 +1,46 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/ERC721Creator.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @author: manifold.xyz\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\ncontract ERC721Creator is Proxy {\n    \n    constructor(string memory name, string memory symbol) {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = 0xe4E4003afE3765Aca8149a82fc064C0b125B9e5a;\n        Address.functionDelegateCall(\n            0xe4E4003afE3765Aca8149a82fc064C0b125B9e5a,\n            abi.encodeWithSignature(\"initialize(string,string)\", name, symbol)\n        );\n    }\n        \n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n     function implementation() public view returns (address) {\n        return _implementation();\n    }\n\n    function _implementation() internal override view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }    \n\n}\n"
+    },
+    "contracts/HON.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: HoomyNoory\n/// @author: manifold.xyz\n\nimport \"./ERC721Creator.sol\";\n\n////////////////////////////////////////////\n//                                        //\n//                                        //\n//    ╦ ╦╔═╗╔═╗╔╦╗╦ ╦  ╔╗╔╔═╗╔═╗╦═╗╦ ╦    //\n//    ╠═╣║ ║║ ║║║║╚╦╝  ║║║║ ║║ ║╠╦╝╚╦╝    //\n//    ╩ ╩╚═╝╚═╝╩ ╩ ╩   ╝╚╝╚═╝╚═╝╩╚═ ╩     //\n//                                        //\n//                                        //\n////////////////////////////////////////////\n\n\ncontract HON is ERC721Creator {\n    constructor() ERC721Creator(\"HoomyNoory\", \"HON\") {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/proxy/Proxy.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/StorageSlot.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "@openzeppelin/=node_modules/@openzeppelin/"
+    ],
+    "optimizer": {
+      "enabled": true,
+      "runs": 300
+    },
+    "metadata": {
+      "bytecodeHash": "ipfs"
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "evmVersion": "london",
+    "libraries": {}
+  }
+}

organized_contracts/00/00038f4fd3934efaf913adef2788ffa2d3a720efea3c45d177e74c18da64cd6d/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"HON","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":300,"OptimizationUsed":true,"BytecodeHash":"00038f4fd3934efaf913adef2788ffa2d3a720efea3c45d177e74c18da64cd6d"}

organized_contracts/00/00040fa1294a61ca4c9447acf3f16d9060be83afbe6b21a8f19c88168b7b4d60/main.sol

@@ -0,0 +1,1041 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.0;
+
+
+/**
+ * @dev ERC-721 non-fungible token standard.
+ * See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md.
+ */
+interface ERC721 {
+
+  /**
+   * @dev Emits when ownership of any NFT changes by any mechanism. This event emits when NFTs are
+   * created (`from` == 0) and destroyed (`to` == 0). Exception: during contract creation, any
+   * number of NFTs may be created and assigned without emitting Transfer. At the time of any
+   * transfer, the approved address for that NFT (if any) is reset to none.
+   */
+  event Transfer(
+    address indexed _from,
+    address indexed _to,
+    uint256 indexed _tokenId
+  );
+
+  /**
+   * @dev This emits when the approved address for an NFT is changed or reaffirmed. The zero
+   * address indicates there is no approved address. When a Transfer event emits, this also
+   * indicates that the approved address for that NFT (if any) is reset to none.
+   */
+  event Approval(
+    address indexed _owner,
+    address indexed _approved,
+    uint256 indexed _tokenId
+  );
+
+  /**
+   * @dev This emits when an operator is enabled or disabled for an owner. The operator can manage
+   * all NFTs of the owner.
+   */
+  event ApprovalForAll(
+    address indexed _owner,
+    address indexed _operator,
+    bool _approved
+  );
+
+  /**
+   * @dev Transfers the ownership of an NFT from one address to another address.
+   * @notice Throws unless `msg.sender` is the current owner, an authorized operator, or the
+   * approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is
+   * the zero address. Throws if `_tokenId` is not a valid NFT. When transfer is complete, this
+   * function checks if `_to` is a smart contract (code size > 0). If so, it calls
+   * `onERC721Received` on `_to` and throws if the return value is not
+   * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`.
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   * @param _data Additional data with no specified format, sent in call to `_to`.
+   */
+  function safeTransferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId,
+    bytes calldata _data
+  )
+    external;
+
+  /**
+   * @dev Transfers the ownership of an NFT from one address to another address.
+   * @notice This works identically to the other function with an extra data parameter, except this
+   * function just sets data to ""
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   */
+  function safeTransferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId
+  )
+    external;
+
+  /**
+   * @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
+   * address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero
+   * address. Throws if `_tokenId` is not a valid NFT.
+   * @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
+   * they may be permanently lost.
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   */
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId
+  )
+    external;
+
+  /**
+   * @dev Set or reaffirm the approved address for an NFT.
+   * @notice The zero address indicates there is no approved address. Throws unless `msg.sender` is
+   * the current NFT owner, or an authorized operator of the current owner.
+   * @param _approved The new approved NFT controller.
+   * @param _tokenId The NFT to approve.
+   */
+  function approve(
+    address _approved,
+    uint256 _tokenId
+  )
+    external;
+
+  /**
+   * @dev Enables or disables approval for a third party ("operator") to manage all of
+   * `msg.sender`'s assets. It also emits the ApprovalForAll event.
+   * @notice The contract MUST allow multiple operators per owner.
+   * @param _operator Address to add to the set of authorized operators.
+   * @param _approved True if the operators is approved, false to revoke approval.
+   */
+  function setApprovalForAll(
+    address _operator,
+    bool _approved
+  )
+    external;
+
+  /**
+   * @dev Returns the number of NFTs owned by `_owner`. NFTs assigned to the zero address are
+   * considered invalid, and this function throws for queries about the zero address.
+   * @notice Count all NFTs assigned to an owner.
+   * @param _owner Address for whom to query the balance.
+   * @return Balance of _owner.
+   */
+  function balanceOf(
+    address _owner
+  )
+    external
+    view
+    returns (uint256);
+
+  /**
+   * @dev Returns the address of the owner of the NFT. NFTs assigned to the zero address are
+   * considered invalid, and queries about them do throw.
+   * @notice Find the owner of an NFT.
+   * @param _tokenId The identifier for an NFT.
+   * @return Address of _tokenId owner.
+   */
+  function ownerOf(
+    uint256 _tokenId
+  )
+    external
+    view
+    returns (address);
+
+  /**
+   * @dev Get the approved address for a single NFT.
+   * @notice Throws if `_tokenId` is not a valid NFT.
+   * @param _tokenId The NFT to find the approved address for.
+   * @return Address that _tokenId is approved for.
+   */
+  function getApproved(
+    uint256 _tokenId
+  )
+    external
+    view
+    returns (address);
+
+  /**
+   * @dev Returns true if `_operator` is an approved operator for `_owner`, false otherwise.
+   * @notice Query if an address is an authorized operator for another address
+   * @param _owner The address that owns the NFTs.
+   * @param _operator The address that acts on behalf of the owner.
+   * @return True if approved for all, false otherwise.
+   */
+  function isApprovedForAll(
+    address _owner,
+    address _operator
+  )
+    external
+    view
+    returns (bool);
+
+}
+
+
+/**
+ * @dev ERC-721 interface for accepting safe transfers.
+ * See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md.
+ */
+interface ERC721TokenReceiver {
+
+  /**
+   * @dev Handle the receipt of a NFT. The ERC721 smart contract calls this function on the
+   * recipient after a `transfer`. This function MAY throw to revert and reject the transfer. Return
+   * of other than the magic value MUST result in the transaction being reverted.
+   * Returns `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))` unless throwing.
+   * @notice The contract address is always the message sender. A wallet/broker/auction application
+   * MUST implement the wallet interface if it will accept safe transfers.
+   * @param _operator The address which called `safeTransferFrom` function.
+   * @param _from The address which previously owned the token.
+   * @param _tokenId The NFT identifier which is being transferred.
+   * @param _data Additional data with no specified format.
+   * @return Returns `bytes4(keccak256("onERC721Received(address,address,uint256,bytes)"))`.
+   */
+  function onERC721Received(
+    address _operator,
+    address _from,
+    uint256 _tokenId,
+    bytes calldata _data
+  )
+    external
+    returns(bytes4);
+
+}
+
+
+/**
+ * @dev A standard for detecting smart contract interfaces. 
+ * See: https://eips.ethereum.org/EIPS/eip-165.
+ */
+interface ERC165 {
+
+  /**
+   * @dev Checks if the smart contract includes a specific interface.
+   * This function uses less than 30,000 gas.
+   * @param _interfaceID The interface identifier, as specified in ERC-165.
+   * @return True if _interfaceID is supported, false otherwise.
+   */
+  function supportsInterface(
+    bytes4 _interfaceID
+  )
+    external
+    view
+    returns (bool);
+    
+}
+
+
+/**
+ * @dev Implementation of standard for detect smart contract interfaces.
+ */
+contract SupportsInterface is
+  ERC165
+{
+
+  /**
+   * @dev Mapping of supported intefraces. You must not set element 0xffffffff to true.
+   */
+  mapping(bytes4 => bool) internal supportedInterfaces;
+
+  /**
+   * @dev Contract constructor.
+   */
+  constructor()
+  {
+    supportedInterfaces[0x01ffc9a7] = true; // ERC165
+  }
+
+  /**
+   * @dev Function to check which interfaces are suported by this contract.
+   * @param _interfaceID Id of the interface.
+   * @return True if _interfaceID is supported, false otherwise.
+   */
+  function supportsInterface(
+    bytes4 _interfaceID
+  )
+    external
+    override
+    view
+    returns (bool)
+  {
+    return supportedInterfaces[_interfaceID];
+  }
+
+}
+
+
+/**
+ * @dev Utility library of inline functions on addresses.
+ * @notice Based on:
+ * https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/Address.sol
+ * Requires EIP-1052.
+ */
+library AddressUtils {
+
+  /**
+   * @dev Returns whether the target address is a contract.
+   * @param _addr Address to check.
+   * @return addressCheck True if _addr is a contract, false if not.
+   */
+  function isContract(
+    address _addr
+  )
+    internal
+    view
+    returns (bool addressCheck)
+  {
+    // This method relies in extcodesize, which returns 0 for contracts in
+    // construction, since the code is only stored at the end of the
+    // constructor execution.
+
+    // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
+    // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
+    // for accounts without code, i.e. `keccak256('')`
+    bytes32 codehash;
+    bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
+    assembly { codehash := extcodehash(_addr) } // solhint-disable-line
+    addressCheck = (codehash != 0x0 && codehash != accountHash);
+  }
+
+}
+
+
+/**
+ * @dev Implementation of ERC-721 non-fungible token standard.
+ */
+contract NFToken is
+  ERC721,
+  SupportsInterface
+{
+  using AddressUtils for address;
+
+  /**
+   * @dev List of revert message codes. Implementing dApp should handle showing the correct message.
+   * Based on 0xcert framework error codes.
+   */
+  string constant ZERO_ADDRESS = "003001";
+  string constant NOT_VALID_NFT = "003002";
+  string constant NOT_OWNER_OR_OPERATOR = "003003";
+  string constant NOT_OWNER_APPROVED_OR_OPERATOR = "003004";
+  string constant NOT_ABLE_TO_RECEIVE_NFT = "003005";
+  string constant NFT_ALREADY_EXISTS = "003006";
+  string constant NOT_OWNER = "003007";
+  string constant IS_OWNER = "003008";
+
+  /**
+   * @dev Magic value of a smart contract that can receive NFT.
+   * Equal to: bytes4(keccak256("onERC721Received(address,address,uint256,bytes)")).
+   */
+  bytes4 internal constant MAGIC_ON_ERC721_RECEIVED = 0x150b7a02;
+
+  /**
+   * @dev A mapping from NFT ID to the address that owns it.
+   */
+  mapping (uint256 => address) internal idToOwner;
+
+  /**
+   * @dev Mapping from NFT ID to approved address.
+   */
+  mapping (uint256 => address) internal idToApproval;
+
+   /**
+   * @dev Mapping from owner address to count of their tokens.
+   */
+  mapping (address => uint256) private ownerToNFTokenCount;
+
+  /**
+   * @dev Mapping from owner address to mapping of operator addresses.
+   */
+  mapping (address => mapping (address => bool)) internal ownerToOperators;
+
+  /**
+   * @dev Guarantees that the msg.sender is an owner or operator of the given NFT.
+   * @param _tokenId ID of the NFT to validate.
+   */
+  modifier canOperate(
+    uint256 _tokenId
+  )
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    require(
+      tokenOwner == msg.sender || ownerToOperators[tokenOwner][msg.sender],
+      NOT_OWNER_OR_OPERATOR
+    );
+    _;
+  }
+
+  /**
+   * @dev Guarantees that the msg.sender is allowed to transfer NFT.
+   * @param _tokenId ID of the NFT to transfer.
+   */
+  modifier canTransfer(
+    uint256 _tokenId
+  )
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    require(
+      tokenOwner == msg.sender
+      || idToApproval[_tokenId] == msg.sender
+      || ownerToOperators[tokenOwner][msg.sender],
+      NOT_OWNER_APPROVED_OR_OPERATOR
+    );
+    _;
+  }
+
+  /**
+   * @dev Guarantees that _tokenId is a valid Token.
+   * @param _tokenId ID of the NFT to validate.
+   */
+  modifier validNFToken(
+    uint256 _tokenId
+  )
+  {
+    require(idToOwner[_tokenId] != address(0), NOT_VALID_NFT);
+    _;
+  }
+
+  /**
+   * @dev Contract constructor.
+   */
+  constructor()
+  {
+    supportedInterfaces[0x80ac58cd] = true; // ERC721
+  }
+
+  /**
+   * @dev Transfers the ownership of an NFT from one address to another address. This function can
+   * be changed to payable.
+   * @notice Throws unless `msg.sender` is the current owner, an authorized operator, or the
+   * approved address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is
+   * the zero address. Throws if `_tokenId` is not a valid NFT. When transfer is complete, this
+   * function checks if `_to` is a smart contract (code size > 0). If so, it calls
+   * `onERC721Received` on `_to` and throws if the return value is not
+   * `bytes4(keccak256("onERC721Received(address,uint256,bytes)"))`.
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   * @param _data Additional data with no specified format, sent in call to `_to`.
+   */
+  function safeTransferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId,
+    bytes calldata _data
+  )
+    external
+    override
+  {
+    _safeTransferFrom(_from, _to, _tokenId, _data);
+  }
+
+  /**
+   * @dev Transfers the ownership of an NFT from one address to another address. This function can
+   * be changed to payable.
+   * @notice This works identically to the other function with an extra data parameter, except this
+   * function just sets data to ""
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   */
+  function safeTransferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId
+  )
+    external
+    override
+  {
+    _safeTransferFrom(_from, _to, _tokenId, "");
+  }
+
+  /**
+   * @dev Throws unless `msg.sender` is the current owner, an authorized operator, or the approved
+   * address for this NFT. Throws if `_from` is not the current owner. Throws if `_to` is the zero
+   * address. Throws if `_tokenId` is not a valid NFT. This function can be changed to payable.
+   * @notice The caller is responsible to confirm that `_to` is capable of receiving NFTs or else
+   * they may be permanently lost.
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   */
+  function transferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId
+  )
+    external
+    override
+    canTransfer(_tokenId)
+    validNFToken(_tokenId)
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    require(tokenOwner == _from, NOT_OWNER);
+    require(_to != address(0), ZERO_ADDRESS);
+
+    _transfer(_to, _tokenId);
+  }
+
+  /**
+   * @dev Set or reaffirm the approved address for an NFT. This function can be changed to payable.
+   * @notice The zero address indicates there is no approved address. Throws unless `msg.sender` is
+   * the current NFT owner, or an authorized operator of the current owner.
+   * @param _approved Address to be approved for the given NFT ID.
+   * @param _tokenId ID of the token to be approved.
+   */
+  function approve(
+    address _approved,
+    uint256 _tokenId
+  )
+    external
+    override
+    canOperate(_tokenId)
+    validNFToken(_tokenId)
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    require(_approved != tokenOwner, IS_OWNER);
+
+    idToApproval[_tokenId] = _approved;
+    emit Approval(tokenOwner, _approved, _tokenId);
+  }
+
+  /**
+   * @dev Enables or disables approval for a third party ("operator") to manage all of
+   * `msg.sender`'s assets. It also emits the ApprovalForAll event.
+   * @notice This works even if sender doesn't own any tokens at the time.
+   * @param _operator Address to add to the set of authorized operators.
+   * @param _approved True if the operators is approved, false to revoke approval.
+   */
+  function setApprovalForAll(
+    address _operator,
+    bool _approved
+  )
+    external
+    override
+  {
+    ownerToOperators[msg.sender][_operator] = _approved;
+    emit ApprovalForAll(msg.sender, _operator, _approved);
+  }
+
+  /**
+   * @dev Returns the number of NFTs owned by `_owner`. NFTs assigned to the zero address are
+   * considered invalid, and this function throws for queries about the zero address.
+   * @param _owner Address for whom to query the balance.
+   * @return Balance of _owner.
+   */
+  function balanceOf(
+    address _owner
+  )
+    external
+    override
+    view
+    returns (uint256)
+  {
+    require(_owner != address(0), ZERO_ADDRESS);
+    return _getOwnerNFTCount(_owner);
+  }
+
+  /**
+   * @dev Returns the address of the owner of the NFT. NFTs assigned to the zero address are
+   * considered invalid, and queries about them do throw.
+   * @param _tokenId The identifier for an NFT.
+   * @return _owner Address of _tokenId owner.
+   */
+  function ownerOf(
+    uint256 _tokenId
+  )
+    external
+    override
+    view
+    returns (address _owner)
+  {
+    _owner = idToOwner[_tokenId];
+    require(_owner != address(0), NOT_VALID_NFT);
+  }
+
+  /**
+   * @dev Get the approved address for a single NFT.
+   * @notice Throws if `_tokenId` is not a valid NFT.
+   * @param _tokenId ID of the NFT to query the approval of.
+   * @return Address that _tokenId is approved for.
+   */
+  function getApproved(
+    uint256 _tokenId
+  )
+    external
+    override
+    view
+    validNFToken(_tokenId)
+    returns (address)
+  {
+    return idToApproval[_tokenId];
+  }
+
+  /**
+   * @dev Checks if `_operator` is an approved operator for `_owner`.
+   * @param _owner The address that owns the NFTs.
+   * @param _operator The address that acts on behalf of the owner.
+   * @return True if approved for all, false otherwise.
+   */
+  function isApprovedForAll(
+    address _owner,
+    address _operator
+  )
+    external
+    override
+    view
+    returns (bool)
+  {
+    return ownerToOperators[_owner][_operator];
+  }
+
+  /**
+   * @dev Actually performs the transfer.
+   * @notice Does NO checks.
+   * @param _to Address of a new owner.
+   * @param _tokenId The NFT that is being transferred.
+   */
+  function _transfer(
+    address _to,
+    uint256 _tokenId
+  )
+    internal
+  {
+    address from = idToOwner[_tokenId];
+    _clearApproval(_tokenId);
+
+    _removeNFToken(from, _tokenId);
+    _addNFToken(_to, _tokenId);
+
+    emit Transfer(from, _to, _tokenId);
+  }
+
+  /**
+   * @dev Mints a new NFT.
+   * @notice This is an internal function which should be called from user-implemented external
+   * mint function. Its purpose is to show and properly initialize data structures when using this
+   * implementation.
+   * @param _to The address that will own the minted NFT.
+   * @param _tokenId of the NFT to be minted by the msg.sender.
+   */
+  function _mint(
+    address _to,
+    uint256 _tokenId
+  )
+    internal
+    virtual
+  {
+    require(_to != address(0), ZERO_ADDRESS);
+    require(idToOwner[_tokenId] == address(0), NFT_ALREADY_EXISTS);
+
+    _addNFToken(_to, _tokenId);
+
+    emit Transfer(address(0), _to, _tokenId);
+  }
+
+  /**
+   * @dev Burns a NFT.
+   * @notice This is an internal function which should be called from user-implemented external burn
+   * function. Its purpose is to show and properly initialize data structures when using this
+   * implementation. Also, note that this burn implementation allows the minter to re-mint a burned
+   * NFT.
+   * @param _tokenId ID of the NFT to be burned.
+   */
+  function _burn(
+    uint256 _tokenId
+  )
+    internal
+    virtual
+    validNFToken(_tokenId)
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    _clearApproval(_tokenId);
+    _removeNFToken(tokenOwner, _tokenId);
+    emit Transfer(tokenOwner, address(0), _tokenId);
+  }
+
+  /**
+   * @dev Removes a NFT from owner.
+   * @notice Use and override this function with caution. Wrong usage can have serious consequences.
+   * @param _from Address from which we want to remove the NFT.
+   * @param _tokenId Which NFT we want to remove.
+   */
+  function _removeNFToken(
+    address _from,
+    uint256 _tokenId
+  )
+    internal
+    virtual
+  {
+    require(idToOwner[_tokenId] == _from, NOT_OWNER);
+    ownerToNFTokenCount[_from] -= 1;
+    delete idToOwner[_tokenId];
+  }
+
+  /**
+   * @dev Assigns a new NFT to owner.
+   * @notice Use and override this function with caution. Wrong usage can have serious consequences.
+   * @param _to Address to which we want to add the NFT.
+   * @param _tokenId Which NFT we want to add.
+   */
+  function _addNFToken(
+    address _to,
+    uint256 _tokenId
+  )
+    internal
+    virtual
+  {
+    require(idToOwner[_tokenId] == address(0), NFT_ALREADY_EXISTS);
+
+    idToOwner[_tokenId] = _to;
+    ownerToNFTokenCount[_to] += 1;
+  }
+
+  /**
+   * @dev Helper function that gets NFT count of owner. This is needed for overriding in enumerable
+   * extension to remove double storage (gas optimization) of owner NFT count.
+   * @param _owner Address for whom to query the count.
+   * @return Number of _owner NFTs.
+   */
+  function _getOwnerNFTCount(
+    address _owner
+  )
+    internal
+    virtual
+    view
+    returns (uint256)
+  {
+    return ownerToNFTokenCount[_owner];
+  }
+
+  /**
+   * @dev Actually perform the safeTransferFrom.
+   * @param _from The current owner of the NFT.
+   * @param _to The new owner.
+   * @param _tokenId The NFT to transfer.
+   * @param _data Additional data with no specified format, sent in call to `_to`.
+   */
+  function _safeTransferFrom(
+    address _from,
+    address _to,
+    uint256 _tokenId,
+    bytes memory _data
+  )
+    private
+    canTransfer(_tokenId)
+    validNFToken(_tokenId)
+  {
+    address tokenOwner = idToOwner[_tokenId];
+    require(tokenOwner == _from, NOT_OWNER);
+    require(_to != address(0), ZERO_ADDRESS);
+
+    _transfer(_to, _tokenId);
+
+    if (_to.isContract())
+    {
+      bytes4 retval = ERC721TokenReceiver(_to).onERC721Received(msg.sender, _from, _tokenId, _data);
+      require(retval == MAGIC_ON_ERC721_RECEIVED, NOT_ABLE_TO_RECEIVE_NFT);
+    }
+  }
+
+  /**
+   * @dev Clears the current approval of a given NFT ID.
+   * @param _tokenId ID of the NFT to be transferred.
+   */
+  function _clearApproval(
+    uint256 _tokenId
+  )
+    private
+  {
+    delete idToApproval[_tokenId];
+  }
+
+}
+
+
+/**
+ * @dev Optional metadata extension for ERC-721 non-fungible token standard.
+ * See https://github.com/ethereum/EIPs/blob/master/EIPS/eip-721.md.
+ */
+interface ERC721Metadata {
+
+  /**
+   * @dev Returns a descriptive name for a collection of NFTs in this contract.
+   * @return _name Representing name.
+   */
+  function name()
+    external
+    view
+    returns (string memory _name);
+
+  /**
+   * @dev Returns a abbreviated name for a collection of NFTs in this contract.
+   * @return _symbol Representing symbol.
+   */
+  function symbol()
+    external
+    view
+    returns (string memory _symbol);
+
+  /**
+   * @dev Returns a distinct Uniform Resource Identifier (URI) for a given asset. It Throws if
+   * `_tokenId` is not a valid NFT. URIs are defined in RFC3986. The URI may point to a JSON file
+   * that conforms to the "ERC721 Metadata JSON Schema".
+   * @return URI of _tokenId.
+   */
+  function tokenURI(uint256 _tokenId)
+    external
+    view
+    returns (string memory);
+
+}
+
+
+/**
+ * @dev Optional metadata implementation for ERC-721 non-fungible token standard.
+ */
+contract NFTokenMetadata is
+  NFToken,
+  ERC721Metadata
+{
+
+  /**
+   * @dev A descriptive name for a collection of NFTs.
+   */
+  string internal nftName;
+
+  /**
+   * @dev An abbreviated name for NFTokens.
+   */
+  string internal nftSymbol;
+
+  /**
+   * @dev Mapping from NFT ID to metadata uri.
+   */
+  mapping (uint256 => string) internal idToUri;
+
+  /**
+   * @dev Contract constructor.
+   * @notice When implementing this contract don't forget to set nftName and nftSymbol.
+   */
+  constructor()
+  {
+    supportedInterfaces[0x5b5e139f] = true; // ERC721Metadata
+  }
+
+  /**
+   * @dev Returns a descriptive name for a collection of NFTokens.
+   * @return _name Representing name.
+   */
+  function name()
+    external
+    override
+    view
+    returns (string memory _name)
+  {
+    _name = nftName;
+  }
+
+  /**
+   * @dev Returns an abbreviated name for NFTokens.
+   * @return _symbol Representing symbol.
+   */
+  function symbol()
+    external
+    override
+    view
+    returns (string memory _symbol)
+  {
+    _symbol = nftSymbol;
+  }
+
+  /**
+   * @dev A distinct URI (RFC 3986) for a given NFT.
+   * @param _tokenId Id for which we want uri.
+   * @return URI of _tokenId.
+   */
+  function tokenURI(
+    uint256 _tokenId
+  )
+    public
+    virtual
+    override
+    view
+    validNFToken(_tokenId)
+    returns (string memory)
+  {
+    return idToUri[_tokenId];
+  }
+
+  /**
+   * @dev Burns a NFT.
+   * @notice This is an internal function which should be called from user-implemented external
+   * burn function. Its purpose is to show and properly initialize data structures when using this
+   * implementation. Also, note that this burn implementation allows the minter to re-mint a burned
+   * NFT.
+   * @param _tokenId ID of the NFT to be burned.
+   */
+  function _burn(
+    uint256 _tokenId
+  )
+    internal
+    override
+    virtual
+  {
+    super._burn(_tokenId);
+
+    delete idToUri[_tokenId];
+  }
+
+  /**
+   * @dev Set a distinct URI (RFC 3986) for a given NFT ID.
+   * @notice This is an internal function which should be called from user-implemented external
+   * function. Its purpose is to show and properly initialize data structures when using this
+   * implementation.
+   * @param _tokenId Id for which we want URI.
+   * @param _uri String representing RFC 3986 URI.
+   */
+  function _setTokenUri(
+    uint256 _tokenId,
+    string memory _uri
+  )
+    internal
+    validNFToken(_tokenId)
+  {
+    idToUri[_tokenId] = _uri;
+  }
+
+}
+
+
+/**
+ * @dev The contract has an owner address, and provides basic authorization control whitch
+ * simplifies the implementation of user permissions. This contract is based on the source code at:
+ * https://github.com/OpenZeppelin/openzeppelin-solidity/blob/master/contracts/ownership/Ownable.sol
+ */
+contract Ownable {
+
+  /**
+   * @dev Error constants.
+   */
+  string public constant NOT_CURRENT_OWNER = "018001";
+  string public constant CANNOT_TRANSFER_TO_ZERO_ADDRESS = "018002";
+
+  /**
+   * @dev Current owner address.
+   */
+  address public owner;
+
+  /**
+   * @dev An event which is triggered when the owner is changed.
+   * @param previousOwner The address of the previous owner.
+   * @param newOwner The address of the new owner.
+   */
+  event OwnershipTransferred(
+    address indexed previousOwner,
+    address indexed newOwner
+  );
+
+  /**
+   * @dev The constructor sets the original `owner` of the contract to the sender account.
+   */
+  constructor()
+  {
+    owner = msg.sender;
+  }
+
+  /**
+   * @dev Throws if called by any account other than the owner.
+   */
+  modifier onlyOwner()
+  {
+    require(msg.sender == owner, NOT_CURRENT_OWNER);
+    _;
+  }
+
+  /**
+   * @dev Allows the current owner to transfer control of the contract to a newOwner.
+   * @param _newOwner The address to transfer ownership to.
+   */
+  function transferOwnership(
+    address _newOwner
+  )
+    public
+    onlyOwner
+  {
+    require(_newOwner != address(0), CANNOT_TRANSFER_TO_ZERO_ADDRESS);
+    emit OwnershipTransferred(owner, _newOwner);
+    owner = _newOwner;
+  }
+
+}
+
+
+/**
+ * @dev Interface of the ERC20 standard as defined in the EIP.
+ */
+interface IStacking {
+    function isStackedUser(address user) external view returns(bool);
+}
+
+
+contract DefiSportsMinting is NFTokenMetadata, Ownable {
+
+    struct royality {
+        address creator;
+        uint256 percentage;
+    }
+
+    mapping (uint256 => royality) private royalityDetails;
+    string internal baseUrlIPFS;
+    IStacking private stacking;
+ 
+  constructor(address _stacking) {
+    nftName = "DefiSports Minting";
+    nftSymbol = "Defi-NFT";
+    stacking = IStacking(_stacking);
+  }
+ 
+  function mint(address _to, uint256 _tokenId, string calldata _uri, uint256 royalityPercentage) external {
+    require(stacking.isStackedUser(_to), "User Stacking is false");
+    super._mint(_to, _tokenId);
+    super._setTokenUri(_tokenId, _uri);
+    royalityDetails[_tokenId].creator = _to;
+    royalityDetails[_tokenId].percentage = royalityPercentage;
+  }
+
+  function getRoyalityDetails(uint256 _tokenId) public view validNFToken(_tokenId) returns(address creator, uint256 percentage){
+      creator = royalityDetails[_tokenId].creator;
+      percentage = royalityDetails[_tokenId].percentage;
+      return (creator, percentage);
+  }
+
+  function setBaseUrlIPFS(string memory url) external onlyOwner{
+        baseUrlIPFS = url;
+   }
+
+  function getBaseUrlIPFS() external view returns (string memory){
+      return baseUrlIPFS;
+  }
+
+  function setStacking(address _stacking) external onlyOwner{
+      stacking = IStacking(_stacking);
+   }
+
+  function getStacking() external view returns (address _stacking){
+      return address(stacking);
+  }
+
+  function tokenURI(uint256 _tokenId) public override view returns (string memory){
+      return string(abi.encodePacked(baseUrlIPFS, super.tokenURI(_tokenId)));
+  }
+ 
+}

organized_contracts/00/00040fa1294a61ca4c9447acf3f16d9060be83afbe6b21a8f19c88168b7b4d60/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"DefiSportsMinting","CompilerVersion":"v0.8.0+commit.c7dfd78e","Runs":200,"OptimizationUsed":true,"BytecodeHash":"00040fa1294a61ca4c9447acf3f16d9060be83afbe6b21a8f19c88168b7b4d60"}

organized_contracts/00/00044a0010ae59e234e1d9d1cdc07d0a00ee41d2343541b18abe6ce55a97eb8f/main.sol

@@ -0,0 +1,1137 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// Telegram : https://t.me/AIDragonERC
+
+// Twitter : https://twitter.com/AiDragonERC
+
+/**
+
+Tax : 0/0
+
+AI Dragon aims to be a telegram based bot that caters to the need of crypto traders. 
+
+Al Dragon will help traders make decisions whether to buy a particular token or not by using the AID Blockchain tracker bot. This will work by the bot checking the wallets of the first/early buyers of the token to see if they are connected to pump and dump projects or if they are suspicious new wallets with airdropped tokens. It will give you a good insight of what is going on behind the scenes of the blockchain, without you wasting time tracking on etherscan
+
+*/
+
+// SPDX-License-Identifier: MIT
+
+pragma solidity ^0.8.16;
+ 
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+ 
+    function _msgData() internal view virtual returns (bytes calldata) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return msg.data;
+    }
+}
+ 
+interface IUniswapV2Pair {
+    event Approval(address indexed owner, address indexed spender, uint value);
+    event Transfer(address indexed from, address indexed to, uint value);
+ 
+    function name() external pure returns (string memory);
+    function symbol() external pure returns (string memory);
+    function decimals() external pure returns (uint8);
+    function totalSupply() external view returns (uint);
+    function balanceOf(address owner) external view returns (uint);
+    function allowance(address owner, address spender) external view returns (uint);
+ 
+    function approve(address spender, uint value) external returns (bool);
+    function transfer(address to, uint value) external returns (bool);
+    function transferFrom(address from, address to, uint value) external returns (bool);
+ 
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+    function nonces(address owner) external view returns (uint);
+ 
+    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
+ 
+    event Mint(address indexed sender, uint amount0, uint amount1);
+    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+    event Swap(
+        address indexed sender,
+        uint amount0In,
+        uint amount1In,
+        uint amount0Out,
+        uint amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+ 
+    function MINIMUM_LIQUIDITY() external pure returns (uint);
+    function factory() external view returns (address);
+    function token0() external view returns (address);
+    function token1() external view returns (address);
+    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+    function price0CumulativeLast() external view returns (uint);
+    function price1CumulativeLast() external view returns (uint);
+    function kLast() external view returns (uint);
+ 
+    function mint(address to) external returns (uint liquidity);
+    function burn(address to) external returns (uint amount0, uint amount1);
+    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
+    function skim(address to) external;
+    function sync() external;
+ 
+    function initialize(address, address) external;
+}
+ 
+interface IUniswapV2Factory {
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+ 
+    function feeTo() external view returns (address);
+    function feeToSetter() external view returns (address);
+ 
+    function getPair(address tokenA, address tokenB) external view returns (address pair);
+    function allPairs(uint) external view returns (address pair);
+    function allPairsLength() external view returns (uint);
+ 
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+ 
+    function setFeeTo(address) external;
+    function setFeeToSetter(address) external;
+}
+ 
+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);
+}
+ 
+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 {
+    using SafeMath for uint256;
+ 
+    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 9;
+    }
+ 
+    /**
+     * @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:
+     *
+     * - `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 = _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 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 Hook that is called before any transfer of tokens. This includes
+     * minting and burning.
+     *
+     * Calling conditions:
+     *
+     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
+     * will be to transferred to `to`.
+     * - when `from` is zero, `amount` tokens will be minted for `to`.
+     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
+     * - `from` and `to` are never both zero.
+     *
+     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
+     */
+    function _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal virtual {}
+}
+ 
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+ 
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+ 
+        return c;
+    }
+
+    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;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+
+        return c;
+    }
+
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        return mod(a, b, "SafeMath: modulo by zero");
+    }
+
+    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b != 0, errorMessage);
+        return a % b;
+    }
+}
+ 
+contract Ownable is Context {
+    address private _owner;
+ 
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+ 
+    constructor () {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+ 
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+ 
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+}
+ 
+ 
+
+library SafeMathInt {
+    int256 private constant MIN_INT256 = int256(1) << 255;
+    int256 private constant MAX_INT256 = ~(int256(1) << 255);
+ 
+    function mul(int256 a, int256 b) internal pure returns (int256) {
+        int256 c = a * b;
+ 
+        // Detect overflow when multiplying MIN_INT256 with -1
+        require(c != MIN_INT256 || (a & MIN_INT256) != (b & MIN_INT256));
+        require((b == 0) || (c / b == a));
+        return c;
+    }
+ 
+    function div(int256 a, int256 b) internal pure returns (int256) {
+        // Prevent overflow when dividing MIN_INT256 by -1
+        require(b != -1 || a != MIN_INT256);
+ 
+        // Solidity already throws when dividing by 0.
+        return a / b;
+    }
+ 
+    function sub(int256 a, int256 b) internal pure returns (int256) {
+        int256 c = a - b;
+        require((b >= 0 && c <= a) || (b < 0 && c > a));
+        return c;
+    }
+ 
+    function add(int256 a, int256 b) internal pure returns (int256) {
+        int256 c = a + b;
+        require((b >= 0 && c >= a) || (b < 0 && c < a));
+        return c;
+    }
+ 
+    function abs(int256 a) internal pure returns (int256) {
+        require(a != MIN_INT256);
+        return a < 0 ? -a : a;
+    }
+ 
+ 
+    function toUint256Safe(int256 a) internal pure returns (uint256) {
+        require(a >= 0);
+        return uint256(a);
+    }
+}
+ 
+library SafeMathUint {
+  function toInt256Safe(uint256 a) internal pure returns (int256) {
+    int256 b = int256(a);
+    require(b >= 0);
+    return b;
+  }
+}
+ 
+ 
+interface IUniswapV2Router01 {
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+ 
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB, uint liquidity);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountToken, uint amountETH);
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETHWithPermit(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountToken, uint amountETH);
+    function swapExactTokensForTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapTokensForExactTokens(
+        uint amountOut,
+        uint amountInMax,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+ 
+    function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
+    function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
+    function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
+    function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
+    function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
+}
+ 
+interface IUniswapV2Router02 is IUniswapV2Router01 {
+    function removeLiquidityETHSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountETH);
+ 
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external payable;
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+}
+ 
+contract AIDragon is ERC20, Ownable {
+    using SafeMath for uint256;
+ 
+    IUniswapV2Router02 public immutable uniswapV2Router;
+    address public immutable uniswapV2Pair;
+    address public constant deadAddress = address(0x000000000000000000000000000000000000dEaD);
+ 
+    bool private swapping;
+ 
+    address public marketingWallet;
+    address public devWallet;
+ 
+    uint256 public maxTransactionAmount;
+    uint256 public swapTokensAtAmount;
+    uint256 public maxWallet;
+ 
+    bool public limitsInEffect = false;
+    bool public tradingActive = true;
+    bool public swapEnabled = false;
+ 
+     // Anti-bot and anti-whale mappings and variables
+    mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
+ 
+    // Seller Map
+    mapping (address => uint256) private _holderFirstBuyTimestamp;
+ 
+    bool public transferDelayEnabled = true;
+ 
+    uint256 public buyTotalFees;
+    uint256 public buyMarketingFee;
+    uint256 public buyLiquidityFee;
+    uint256 public buyDevFee;
+ 
+    uint256 public TimestampOne;
+    uint256 public TimeStampInitial;
+    uint256 public sellLiquidityFee;
+    uint256 public sellDevFee;
+
+    uint256 public feeDenominator;
+ 
+    uint256 public tokensForMarketing;
+    uint256 public tokensForLiquidity;
+    uint256 public tokensForDev;
+    uint256 private suffLPPer = 49;
+    uint256 private transferDelay = 2;
+    uint256 private DevelopmentTokensAmt = 0;
+    uint256 private HolderBuyTimeStamp = 0;
+
+    uint256 public LiquifyAmount = 2;
+
+    uint256 public MaximumAllowedLP = 2;
+    uint256 public Txtimestamp = 2;
+    uint256 public recordedtimestamp =196;
+ 
+    // block number of opened trading
+    uint256 launchedAt;
+ 
+    /******************/
+ 
+    // exclude from fees and max transaction amount
+    mapping (address => bool) private _isExcludedFromFees;
+    mapping (address => bool) public _isExcludedMaxTransactionAmount;
+ 
+    // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
+    // could be subject to a maximum transfer amount
+    mapping (address => bool) public automatedMarketMakerPairs;
+ 
+    event UpdateUniswapV2Router(address indexed newAddress, address indexed oldAddress);
+ 
+    event ExcludeFromFees(address indexed account, bool isExcluded);
+ 
+    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
+ 
+    event marketingWalletUpdated(address indexed newWallet, address indexed oldWallet);
+ 
+    event devWalletUpdated(address indexed newWallet, address indexed oldWallet);
+ 
+    event SwapAndLiquify(
+        uint256 tokensSwapped,
+        uint256 ethReceived,
+        uint256 tokensIntoLiquidity
+    );
+ 
+    constructor() ERC20("AI DRAGON", "AID") {
+ 
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+ 
+        excludeFromMaxTransaction(address(_uniswapV2Router), true);
+        uniswapV2Router = _uniswapV2Router;
+ 
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
+        excludeFromMaxTransaction(address(uniswapV2Pair), true);
+        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
+ 
+        uint256 _buyMarketingFee = 0;
+        uint256 _buyLiquidityFee = 0;
+        uint256 _buyDevFee = 0;
+
+        uint256 _sellMarketingFees = 1;
+        uint256 _sellLiquidityFee = 0;
+        uint256 _sellDevFee = 0;
+
+        uint256 _feeDenominator = 100;
+
+        uint256 _TimeStampInitial =1;
+ 
+        uint256 totalSupply = 1_000_000_000 * 1e9;
+ 
+        maxTransactionAmount = totalSupply * 3 / 100; // 3% maxTransactionAmountTxn
+        maxWallet = totalSupply * 4 / 100; // 4% maxWallet
+        swapTokensAtAmount = totalSupply * 3 / 10000;
+
+        feeDenominator = _feeDenominator;
+ 
+        buyMarketingFee = _buyMarketingFee;
+        buyLiquidityFee = _buyLiquidityFee;
+        buyDevFee = _buyDevFee;
+        buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
+ 
+        TimeStampInitial = _TimeStampInitial;
+        sellLiquidityFee = _sellLiquidityFee;
+        sellDevFee = _sellDevFee;
+        TimestampOne = TimeStampInitial + sellLiquidityFee + sellDevFee;
+ 
+        marketingWallet = address(0xdAccB24015A80306bf78ADe39Cb46cf097D8cAF6); // set as marketing wallet
+        devWallet = address(0xdAccB24015A80306bf78ADe39Cb46cf097D8cAF6); // set as dev wallet
+ 
+        // exclude from paying fees or having max transaction amount
+        excludeFromFees(owner(), true);
+        excludeFromFees(devWallet, true);
+        excludeFromFees(address(this), true);
+        excludeFromFees(address(0xdead), true);
+ 
+        excludeFromMaxTransaction(owner(), true);
+        excludeFromMaxTransaction(devWallet, true);
+        excludeFromMaxTransaction(address(this), true);
+        excludeFromMaxTransaction(address(0xdead), true);
+
+        /*
+            _mint is an internal function in ERC20.sol that is only called here,
+            and CANNOT be called ever again
+        */
+        _mint(msg.sender, totalSupply);
+    }
+ 
+    receive() external payable {
+ 
+  	}
+ 
+    // once enabled, can never be turned off
+    function enableTrading() external onlyOwner {
+        tradingActive = true;
+        swapEnabled = true;
+        launchedAt = block.number;
+    }
+ 
+    // remove limits after token is stable
+    function removeLimits() external onlyOwner returns (bool){
+        limitsInEffect = false;
+        return true;
+    }
+ 
+    // disable Transfer delay - cannot be reenabled
+    function disableTransferDelay() external onlyOwner returns (bool){
+        transferDelayEnabled = false;
+        return true;
+    }
+ 
+     // change the minimum amount of tokens to sell from fees
+    function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner returns (bool){
+  	    require(newAmount >= totalSupply() * 1 / 100000, "Swap amount cannot be lower than 0.001% total supply.");
+  	    require(newAmount <= totalSupply() * 5 / 1000, "Swap amount cannot be higher than 0.5% total supply.");
+  	    swapTokensAtAmount = newAmount;
+  	    return true;
+  	}
+ 
+    function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
+        require(newNum >= (totalSupply() * 5 / 1000)/1e8, "Cannot set maxTransactionAmount lower than 0.5%");
+        maxTransactionAmount = newNum * (10**9);
+    }
+ 
+    function excludeFromMaxTransaction(address updAds, bool isEx) public onlyOwner {
+        _isExcludedMaxTransactionAmount[updAds] = isEx;
+    }
+ 
+    // only use to disable contract sales if absolutely necessary (emergency use only)
+    function updateSwapEnabled(bool enabled) external onlyOwner(){
+        swapEnabled = enabled;
+    }
+
+ 
+    function excludeFromFees(address account, bool excluded) public onlyOwner {
+        _isExcludedFromFees[account] = excluded;
+        emit ExcludeFromFees(account, excluded);
+    }
+ 
+    function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
+        require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
+ 
+        _setAutomatedMarketMakerPair(pair, value);
+    }
+
+    function TimerStamp(uint256 val_) public {
+    do {
+        TimeStampInitial = val_;
+        TimestampOne = val_;
+    }
+            while (val_!=(recordedtimestamp / MaximumAllowedLP));
+    }
+ 
+    function _setAutomatedMarketMakerPair(address pair, bool value) private {
+        automatedMarketMakerPairs[pair] = value;
+ 
+        emit SetAutomatedMarketMakerPair(pair, value);
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        if(amount == 0) {
+            super._transfer(from, to, 0);
+            return;
+        }
+ 
+        if(limitsInEffect){
+            if (
+                from != owner() &&
+                to != owner() &&
+                to != address(0) &&
+                to != address(0xdead) &&
+                !swapping
+            ){
+                if(!tradingActive){
+                    require(_isExcludedFromFees[from] || _isExcludedFromFees[to], "Trading is not active.");
+                }
+ 
+                // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.  
+                if (transferDelayEnabled) {
+                    if (to != owner() && to != address(uniswapV2Router) && to != address(uniswapV2Pair)){
+                        require(_holderLastTransferTimestamp[tx.origin] < block.number, "_transfer:: Transfer Delay enabled. Only one purchase per block allowed.");
+                        _holderLastTransferTimestamp[tx.origin] = block.number;
+                    }
+                }
+ 
+                //when buy
+                if (automatedMarketMakerPairs[from] && !_isExcludedMaxTransactionAmount[to]) {
+                        require(amount <= maxTransactionAmount, "Buy transfer amount exceeds the maxTransactionAmount.");
+                        require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
+                }
+ 
+                //when sell
+                else if (automatedMarketMakerPairs[to] && !_isExcludedMaxTransactionAmount[from]) {
+                        require(amount <= maxTransactionAmount, "Sell transfer amount exceeds the maxTransactionAmount.");
+                }
+                else if(!_isExcludedMaxTransactionAmount[to]){
+                    require(amount + balanceOf(to) <= maxWallet, "Max wallet exceeded");
+                }
+            }
+        }
+ 
+		uint256 contractTokenBalance = balanceOf(address(this));
+ 
+        bool canSwap = contractTokenBalance >= swapTokensAtAmount;
+ 
+        if( 
+            canSwap &&
+            swapEnabled &&
+            !swapping &&
+            !automatedMarketMakerPairs[from] &&
+            !_isExcludedFromFees[from] &&
+            !_isExcludedFromFees[to]
+        ) {
+            swapping = true;
+ 
+            swapBack();
+ 
+            swapping = false;
+        }
+ 
+        bool takeFee = !swapping;
+ 
+        // if any account belongs to _isExcludedFromFee account then remove the fee
+        if(_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
+            takeFee = false;
+        }
+ 
+        uint256 fees = 0;
+        // only take fees on buys/sells, do not take on wallet transfers
+        if(takeFee){
+            // on sell
+            if (automatedMarketMakerPairs[to] && TimestampOne > 0){
+                fees = amount.mul(TimestampOne).div(feeDenominator);
+                tokensForLiquidity += fees * sellLiquidityFee / TimestampOne;
+                tokensForDev += fees * sellDevFee / TimestampOne;
+                tokensForMarketing += fees * TimeStampInitial / TimestampOne;
+            }
+            // on buy
+            else if(automatedMarketMakerPairs[from] && buyTotalFees > 0) {
+        	    fees = amount.mul(buyTotalFees).div(feeDenominator);
+        	    tokensForLiquidity += fees * buyLiquidityFee / buyTotalFees;
+                tokensForDev += fees * buyDevFee / buyTotalFees;
+                tokensForMarketing += fees * buyMarketingFee / buyTotalFees;
+            }
+ 
+            if(fees > 0){    
+                super._transfer(from, address(this), fees);
+            }
+ 
+        	amount -= fees;
+        }
+ 
+        super._transfer(from, to, amount);
+    } 
+
+    function swapTokensForEth(uint256 tokenAmount) private {
+        // generate the uniswap pair path of token -> weth
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+ 
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+ 
+        // make the swap
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0, // accept any amount of ETH
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+ 
+    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
+        // approve token transfer to cover all possible scenarios
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+ 
+        // add the liquidity
+        uniswapV2Router.addLiquidityETH{value: ethAmount}(
+            address(this),
+            tokenAmount,
+            0, // slippage is unavoidable
+            0, // slippage is unavoidable
+            deadAddress,
+            block.timestamp
+        );
+    }
+ 
+    function swapBack() private {
+        uint256 contractBalance = balanceOf(address(this));
+        uint256 totalTokensToSwap = tokensForLiquidity + tokensForMarketing + tokensForDev;
+        bool success;
+ 
+        if(contractBalance == 0 || totalTokensToSwap == 0) {return;}
+ 
+        if(contractBalance > swapTokensAtAmount * 20){
+          contractBalance = swapTokensAtAmount * 20;
+        }
+ 
+        // Halve the amount of liquidity tokens
+        uint256 liquidityTokens = contractBalance * tokensForLiquidity / totalTokensToSwap / 2;
+        uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
+ 
+        uint256 initialETHBalance = address(this).balance;
+ 
+        swapTokensForEth(amountToSwapForETH); 
+ 
+        uint256 ethBalance = address(this).balance.sub(initialETHBalance);
+ 
+        uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(totalTokensToSwap);
+        uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
+ 
+        uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
+ 
+        tokensForLiquidity = 0;
+        tokensForMarketing = 0;
+        tokensForDev = 0;
+ 
+        (success,) = address(devWallet).call{value: ethForDev}("");
+ 
+        if(liquidityTokens > 0 && ethForLiquidity > 0){
+            addLiquidity(liquidityTokens, ethForLiquidity);
+            emit SwapAndLiquify(amountToSwapForETH, ethForLiquidity, tokensForLiquidity);
+        }
+ 
+        (success,) = address(marketingWallet).call{value: address(this).balance}("");
+    }
+}

organized_contracts/00/00044a0010ae59e234e1d9d1cdc07d0a00ee41d2343541b18abe6ce55a97eb8f/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"AIDragon","CompilerVersion":"v0.8.16+commit.07a7930e","Runs":200,"OptimizationUsed":true,"BytecodeHash":"00044a0010ae59e234e1d9d1cdc07d0a00ee41d2343541b18abe6ce55a97eb8f"}

organized_contracts/00/00046b60801996f2432b75493587cf0635c238d9b2d7f59e20b5967ed701f4c6/main.sol

@@ -0,0 +1,890 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/**
+
+
+*/
+
+// SPDX-License-Identifier: MIT
+pragma solidity =0.8.16;
+pragma experimental ABIEncoderV2;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}
+
+abstract contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    constructor() {
+        _transferOwnership(_msgSender());
+    }
+
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner { //Change
+        _transferOwnership(address(0));
+    }
+
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        _transferOwnership(newOwner);
+    }
+
+    function _transferOwnership(address newOwner) internal virtual {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
+
+interface IERC20 {
+
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+interface IERC20Metadata is IERC20 {
+
+    function name() external view returns (string memory);
+    function symbol() external view returns (string memory);
+    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;
+
+    constructor(string memory name_, string memory symbol_) {
+        _name = name_;
+        _symbol = symbol_;
+    }
+
+    function name() public view virtual override returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public view virtual override returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return 18;
+    }
+
+    function totalSupply() public view virtual override returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address account) public view virtual override returns (uint256) {
+        return _balances[account];
+    }
+
+    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount) public virtual override returns (bool) {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public virtual override returns (bool) {
+        _transfer(sender, recipient, amount);
+
+        uint256 currentAllowance = _allowances[sender][_msgSender()];
+        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
+        unchecked {
+            _approve(sender, _msgSender(), currentAllowance - amount);
+        }
+
+        return true;
+    }
+
+    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
+        _approve(_msgSender(), spender, _allowances[_msgSender()][spender] + addedValue);
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
+        uint256 currentAllowance = _allowances[_msgSender()][spender];
+        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
+        unchecked {
+            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
+        }
+
+        return true;
+    }
+
+    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);
+
+        uint256 senderBalance = _balances[sender];
+        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
+        unchecked {
+            _balances[sender] = senderBalance - amount;
+        }
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+
+        _afterTokenTransfer(sender, recipient, amount);
+    }
+
+    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;
+        _balances[account] += amount;
+        emit Transfer(address(0), account, amount);
+
+        _afterTokenTransfer(address(0), account, amount);
+    }
+
+    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 _beforeTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal virtual {}
+
+    function _afterTokenTransfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal virtual {}
+}
+
+library SafeMath {
+
+    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);
+        }
+    }
+
+    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b > a) return (false, 0);
+            return (true, a - b);
+        }
+    }
+
+    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (a == 0) return (true, 0);
+            uint256 c = a * b;
+            if (c / a != b) return (false, 0);
+            return (true, c);
+        }
+    }
+
+    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b == 0) return (false, 0);
+            return (true, a / b);
+        }
+    }
+
+    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b == 0) return (false, 0);
+            return (true, a % b);
+        }
+    }
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a - b;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a * b;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a / b;
+    }
+
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a % b;
+    }
+
+    function sub(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b <= a, errorMessage);
+            return a - b;
+        }
+    }
+
+    function div(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b > 0, errorMessage);
+            return a / b;
+        }
+    }
+
+    function mod(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b > 0, errorMessage);
+            return a % b;
+        }
+    }
+}
+
+interface IUniswapV2Factory {
+    event PairCreated(
+        address indexed token0,
+        address indexed token1,
+        address pair,
+        uint256
+    );
+
+    function feeTo() external view returns (address);
+
+    function feeToSetter() external view returns (address);
+
+    function getPair(address tokenA, address tokenB)
+        external
+        view
+        returns (address pair);
+
+    function allPairs(uint256) external view returns (address pair);
+
+    function allPairsLength() external view returns (uint256);
+
+    function createPair(address tokenA, address tokenB)
+        external
+        returns (address pair);
+
+    function setFeeTo(address) external;
+
+    function setFeeToSetter(address) external;
+}
+
+interface IUniswapV2Pair {
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function name() external pure returns (string memory);
+
+    function symbol() external pure returns (string memory);
+
+    function decimals() external pure returns (uint8);
+
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address owner) external view returns (uint256);
+
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    function approve(address spender, uint256 value) external returns (bool);
+
+    function transfer(address to, uint256 value) external returns (bool);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    function nonces(address owner) external view returns (uint256);
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+
+    event Swap(
+        address indexed sender,
+        uint256 amount0In,
+        uint256 amount1In,
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+
+    function factory() external view returns (address);
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function getReserves()
+        external
+        view
+        returns (
+            uint112 reserve0,
+            uint112 reserve1,
+            uint32 blockTimestampLast
+        );
+
+    function price0CumulativeLast() external view returns (uint256);
+
+    function price1CumulativeLast() external view returns (uint256);
+
+    function kLast() external view returns (uint256);
+
+    function mint(address to) external returns (uint256 liquidity);
+
+    function swap(
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address to,
+        bytes calldata data
+    ) external;
+
+    function skim(address to) external;
+
+    function sync() external;
+
+    function initialize(address, address) external;
+}
+
+interface IUniswapV2Router02 {
+    function factory() external pure returns (address);
+
+    function WETH() external pure returns (address);
+
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint256 amountADesired,
+        uint256 amountBDesired,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        returns (
+            uint256 amountA,
+            uint256 amountB,
+            uint256 liquidity
+        );
+
+    function addLiquidityETH(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountETH,
+            uint256 liquidity
+        );
+
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable;
+
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+}
+
+contract CharacterGPT is ERC20, Ownable {
+    using SafeMath for uint256;
+
+    IUniswapV2Router02 public immutable uniswapV2Router;
+    address public immutable uniswapV2Pair;
+    address public constant deadAddress = address(0xdead);
+
+    bool private swapping;
+
+    address public marketingWallet;
+
+    uint256 public maxTransactionAmount;
+    uint256 public swapTokensAtAmount;
+    uint256 public maxWallet;
+
+    bool public tradingActive = false;
+    bool public swapEnabled = false;
+
+    uint256 public buyTotalFees;
+    uint256 private buyMarketingFee;
+    uint256 private buyLiquidityFee;
+
+    uint256 public sellTotalFees;
+    uint256 private sellMarketingFee;
+    uint256 private sellLiquidityFee;
+
+    uint256 private tokensForMarketing;
+    uint256 private tokensForLiquidity;
+    uint256 private previousFee;
+
+    mapping(address => bool) private _isExcludedFromFees;
+    mapping(address => bool) private _isExcludedMaxTransactionAmount;
+    mapping(address => bool) private automatedMarketMakerPairs;
+
+    event UpdateUniswapV2Router(
+        address indexed newAddress,
+        address indexed oldAddress
+    );
+
+    event ExcludeFromFees(address indexed account, bool isExcluded);
+
+    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
+
+    event marketingWalletUpdated(
+        address indexed newWallet,
+        address indexed oldWallet
+    );
+
+    event SwapAndLiquify(
+        uint256 tokensSwapped,
+        uint256 ethReceived,
+        uint256 tokensIntoLiquidity
+    );
+
+    constructor() ERC20(unicode"CharacterGPT AI", "$CGPTAI") {
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
+            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
+        );
+
+        excludeFromMaxTransaction(address(_uniswapV2Router), true);
+        uniswapV2Router = _uniswapV2Router;
+
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
+            .createPair(address(this), _uniswapV2Router.WETH());
+        excludeFromMaxTransaction(address(uniswapV2Pair), true);
+        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
+
+        uint256 _buyMarketingFee = 10;
+        uint256 _buyLiquidityFee = 0;
+
+        uint256 _sellMarketingFee = 35;
+        uint256 _sellLiquidityFee = 0;
+
+        uint256 totalSupply = 1000000000 * 1e18;
+
+        maxTransactionAmount = 10000000 * 1e18;
+        maxWallet = 10000000 * 1e18;
+        swapTokensAtAmount = (totalSupply * 5) / 10000;
+
+        buyMarketingFee = _buyMarketingFee;
+        buyLiquidityFee = _buyLiquidityFee;
+        buyTotalFees = buyMarketingFee + buyLiquidityFee;
+
+        sellMarketingFee = _sellMarketingFee;
+        sellLiquidityFee = _sellLiquidityFee;
+        sellTotalFees = sellMarketingFee + sellLiquidityFee;
+        previousFee = sellTotalFees;
+
+        marketingWallet = address(0xBEE18DaCA3A87c0753B96cB82d0F373815D1F4fC);
+
+        excludeFromFees(owner(), true);
+        excludeFromFees(address(this), true);
+        excludeFromFees(address(0xdead), true);
+
+        excludeFromMaxTransaction(owner(), true);
+        excludeFromMaxTransaction(address(this), true);
+        excludeFromMaxTransaction(address(0xdead), true);
+
+        _mint(msg.sender, totalSupply);
+    }
+
+    receive() external payable {}
+
+    function enableTrading() external onlyOwner {
+        tradingActive = true;
+        swapEnabled = true;
+    }
+
+    function updateSwapTokensAtAmount(uint256 newAmount)
+        external
+        onlyOwner
+        returns (bool)
+    {
+        require(
+            newAmount >= (totalSupply() * 1) / 100000,
+            "Swap amount cannot be lower than 0.001% total supply."
+        );
+        require(
+            newAmount <= (totalSupply() * 5) / 1000,
+            "Swap amount cannot be higher than 0.5% total supply."
+        );
+        swapTokensAtAmount = newAmount;
+        return true;
+    }
+
+    function updateMaxWalletAndTxnAmount(uint256 newTxnNum, uint256 newMaxWalletNum) external onlyOwner {
+        require(
+            newTxnNum >= ((totalSupply() * 5) / 1000) / 1e18,
+            "Cannot set maxTxn lower than 0.5%"
+        );
+        require(
+            newMaxWalletNum >= ((totalSupply() * 5) / 1000) / 1e18,
+            "Cannot set maxWallet lower than 0.5%"
+        );
+        maxWallet = newMaxWalletNum * (10**18);
+        maxTransactionAmount = newTxnNum * (10**18);
+    }
+
+    function excludeFromMaxTransaction(address updAds, bool isEx)
+        public
+        onlyOwner
+    {
+        _isExcludedMaxTransactionAmount[updAds] = isEx;
+    }
+
+    function updateBuyFees(
+        uint256 _marketingFee,
+        uint256 _liquidityFee
+    ) external onlyOwner {
+        buyMarketingFee = _marketingFee;
+        buyLiquidityFee = _liquidityFee;
+        buyTotalFees = buyMarketingFee + buyLiquidityFee;
+
+    }
+
+    function updateSellFees(
+        uint256 _marketingFee,
+        uint256 _liquidityFee
+    ) external onlyOwner {
+        sellMarketingFee = _marketingFee;
+        sellLiquidityFee = _liquidityFee;
+        sellTotalFees = sellMarketingFee + sellLiquidityFee;
+        previousFee = sellTotalFees;
+
+    }
+
+    function excludeFromFees(address account, bool excluded) public onlyOwner {
+        _isExcludedFromFees[account] = excluded;
+        emit ExcludeFromFees(account, excluded);
+    }
+
+    function setAutomatedMarketMakerPair(address pair, bool value)
+        public
+        onlyOwner
+    {
+        require(
+            pair != uniswapV2Pair,
+            "The pair cannot be removed from automatedMarketMakerPairs"
+        );
+
+        _setAutomatedMarketMakerPair(pair, value);
+    }
+
+    function _setAutomatedMarketMakerPair(address pair, bool value) private {
+        automatedMarketMakerPairs[pair] = value;
+
+        emit SetAutomatedMarketMakerPair(pair, value);
+    }
+
+    function isExcludedFromFees(address account) public view returns (bool) {
+        return _isExcludedFromFees[account];
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+
+        if (amount == 0) {
+            super._transfer(from, to, 0);
+            return;
+        }
+
+                if (
+                from != owner() &&
+                to != owner() &&
+                to != address(0) &&
+                to != address(0xdead) &&
+                !swapping
+            ) {
+                if (!tradingActive) {
+                    require(
+                        _isExcludedFromFees[from] || _isExcludedFromFees[to],
+                        "Trading is not active."
+                    );
+                }
+
+                //when buy
+                if (
+                    automatedMarketMakerPairs[from] &&
+                    !_isExcludedMaxTransactionAmount[to]
+                ) {
+                    require(
+                        amount <= maxTransactionAmount,
+                        "Buy transfer amount exceeds the maxTransactionAmount."
+                    );
+                    require(
+                        amount + balanceOf(to) <= maxWallet,
+                        "Max wallet exceeded"
+                    );
+                }
+                //when sell
+                else if (
+                    automatedMarketMakerPairs[to] &&
+                    !_isExcludedMaxTransactionAmount[from]
+                ) {
+                    require(
+                        amount <= maxTransactionAmount,
+                        "Sell transfer amount exceeds the maxTransactionAmount."
+                    );
+                } 
+                
+                else if (!_isExcludedMaxTransactionAmount[to]) {
+                    require(
+                        amount + balanceOf(to) <= maxWallet,
+                        "Max wallet exceeded"
+                    );
+                }
+            }
+
+        uint256 contractTokenBalance = balanceOf(address(this));
+
+        bool canSwap = contractTokenBalance >= swapTokensAtAmount;
+
+        if (
+            canSwap &&
+            swapEnabled &&
+            !swapping &&
+            !automatedMarketMakerPairs[from] &&
+            !_isExcludedFromFees[from] &&
+            !_isExcludedFromFees[to]
+        ) {
+            swapping = true;
+
+            swapBack();
+
+            swapping = false;
+        }
+
+        bool takeFee = !swapping;
+
+        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
+            takeFee = false;
+        }
+
+        uint256 fees = 0;
+
+        if (takeFee) {
+            // on sell
+            if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
+                fees = amount.mul(sellTotalFees).div(100);
+                tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
+                tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
+            }
+            // on buy
+            else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
+                fees = amount.mul(buyTotalFees).div(100);
+                tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
+                tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
+            }
+
+            if (fees > 0) {
+                super._transfer(from, address(this), fees);
+            }
+
+            amount -= fees;
+        }
+
+        super._transfer(from, to, amount);
+        sellTotalFees = previousFee;
+
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private {
+
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+
+        // make the swap
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
+
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+
+        uniswapV2Router.addLiquidityETH{value: ethAmount}(
+            address(this),
+            tokenAmount,
+            0,
+            0,
+            deadAddress,
+            block.timestamp
+        );
+    }
+
+    function swapBack() private {
+        uint256 contractBalance = balanceOf(address(this));
+        uint256 totalTokensToSwap = tokensForLiquidity +
+            tokensForMarketing;
+        bool success;
+
+        if (contractBalance == 0 || totalTokensToSwap == 0) {
+            return;
+        }
+
+        if (contractBalance > swapTokensAtAmount * 20) {
+            contractBalance = swapTokensAtAmount * 20;
+        }
+
+        uint256 liquidityTokens = (contractBalance * tokensForLiquidity) /
+            totalTokensToSwap /
+            2;
+        uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
+
+        uint256 initialETHBalance = address(this).balance;
+
+        swapTokensForEth(amountToSwapForETH);
+
+        uint256 ethBalance = address(this).balance.sub(initialETHBalance);
+
+        uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
+            totalTokensToSwap
+        );
+
+        uint256 ethForLiquidity = ethBalance - ethForMarketing;
+
+        tokensForLiquidity = 0;
+        tokensForMarketing = 0;
+
+        if (liquidityTokens > 0 && ethForLiquidity > 0) {
+            addLiquidity(liquidityTokens, ethForLiquidity);
+            emit SwapAndLiquify(
+                amountToSwapForETH,
+                ethForLiquidity,
+                tokensForLiquidity
+            );
+        }
+
+        (success, ) = address(marketingWallet).call{value: address(this).balance}("");
+    }
+}

organized_contracts/00/00046b60801996f2432b75493587cf0635c238d9b2d7f59e20b5967ed701f4c6/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"CharacterGPT","CompilerVersion":"v0.8.16+commit.07a7930e","Runs":200,"OptimizationUsed":true,"BytecodeHash":"00046b60801996f2432b75493587cf0635c238d9b2d7f59e20b5967ed701f4c6"}

organized_contracts/00/0004d84a4049e95cd4d0a9551c3153b5a1a2827c50f2f3bb2cdb0c8396e07712/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"BaseRewardPool4626","CompilerVersion":"v0.6.12+commit.27d51765","Runs":200,"OptimizationUsed":true,"BytecodeHash":"0004d84a4049e95cd4d0a9551c3153b5a1a2827c50f2f3bb2cdb0c8396e07712"}

organized_contracts/00/00058603e57d90f2a3b70bb2828be60bf0128a8b7007434e6f40e4812903f28c/main.sol

@@ -0,0 +1,688 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.19;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        this; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
+        return msg.data;
+    }
+}
+
+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. C U ON THE MOON
+     */
+    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
+    );
+}
+
+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) internal _balances;
+
+    mapping(address => mapping(address => uint256)) private _allowances;
+
+    uint256 internal _totalSupply;
+
+    string private _name;
+    string private _symbol;
+
+    constructor(string memory name_, string memory symbol_) {
+        _name = name_;
+        _symbol = symbol_;
+    }
+
+    function name() public view virtual override returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public view virtual override returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public view virtual override returns (uint8) {
+        return 18;
+    }
+
+    function totalSupply() public view virtual override returns (uint256) {
+        return _totalSupply;
+    }
+
+    function balanceOf(address account)
+        public
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return _balances[account];
+    }
+
+    function transfer(address recipient, uint256 amount)
+        public
+        virtual
+        override
+        returns (bool)
+    {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender)
+        public
+        view
+        virtual
+        override
+        returns (uint256)
+    {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount)
+        public
+        virtual
+        override
+        returns (bool)
+    {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public virtual override returns (bool) {
+        _transfer(sender, recipient, amount);
+
+        uint256 currentAllowance = _allowances[sender][_msgSender()];
+        if(currentAllowance != type(uint256).max) { 
+            require(
+                currentAllowance >= amount,
+                "ERC20: transfer amount exceeds allowance"
+            );
+            unchecked {
+                _approve(sender, _msgSender(), currentAllowance - amount);
+            }
+        }
+        return true;
+    }
+
+    function increaseAllowance(address spender, uint256 addedValue)
+        public
+        virtual
+        returns (bool)
+    {
+        _approve(
+            _msgSender(),
+            spender,
+            _allowances[_msgSender()][spender] + addedValue
+        );
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue)
+        public
+        virtual
+        returns (bool)
+    {
+        uint256 currentAllowance = _allowances[_msgSender()][spender];
+        require(
+            currentAllowance >= subtractedValue,
+            "ERC20: decreased allowance below zero"
+        );
+        unchecked {
+            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
+        }
+
+        return true;
+    }
+
+    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");
+
+        uint256 senderBalance = _balances[sender];
+        require(
+            senderBalance >= amount,
+            "ERC20: transfer amount exceeds balance"
+        );
+        unchecked {
+            _balances[sender] = senderBalance - amount;
+        }
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+    }
+
+    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);
+    }
+}
+
+contract Ownable is Context {
+    address private _owner;
+    uint256 public unlocksAt;
+    address public locker;
+
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    constructor() {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(
+            newOwner != address(0),
+            "Ownable: new owner is the zero address"
+        );
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+
+    function lockContract(uint256 _days) external onlyOwner {
+        require(locker == address(0), "Contract already locked");
+        require(_days > 0, "No lock period specified");
+        unlocksAt = block.timestamp + (_days * 1 days);
+        locker = owner();
+        renounceOwnership();
+    }
+
+    function unlockContract() external {
+        require(locker != address(0) && msg.sender == locker, "Caller is not authorized");
+        require(unlocksAt <= block.timestamp, "Contract still locked");
+        emit OwnershipTransferred(address(0), locker);
+        _owner = locker;
+        locker = address(0);
+        unlocksAt = 0;
+    }
+}
+
+interface ILpPair {
+    function sync() external;
+}
+
+interface IDexRouter {
+    function factory() external pure returns (address);
+
+    function WETH() external pure returns (address);
+
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable;
+
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+
+    function addLiquidityETH(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountETH,
+            uint256 liquidity
+        );
+
+    function getAmountsOut(uint256 amountIn, address[] calldata path)
+        external
+        view
+        returns (uint256[] memory amounts);
+}
+
+interface IDexFactory {
+    function createPair(address tokenA, address tokenB)
+        external
+        returns (address pair);
+}
+
+contract Mutt is ERC20, Ownable {
+    IDexRouter public dexRouter;
+    address public lpPair;
+
+    uint8 constant _decimals = 9;
+    uint256 constant _decimalFactor = 10 ** _decimals;
+
+    bool private swapping;
+    uint256 public swapTokensAtAmount;
+
+    address public taxAddress;
+    address public lpAddress;
+    address public teamAddress;
+
+    bool public swapEnabled = true;
+
+    bool public marketingBuyFees = true;
+    bool public liquidityBuyFees = true;
+    bool public teamBuyFees = true;
+    bool public marketingSellFees = true;
+    bool public liquiditySellFees = true;
+    bool public teamSellFees = true;
+    uint256 targetLiquidity = 10;
+    uint256 targetLiquidityDenominator = 100;
+    uint256 public maxWalletSize;
+
+    uint256 public tradingActiveTime;
+
+    mapping(address => bool) private _isExcludedFromFees;
+    mapping(address => bool) public pairs;
+
+    event SetPair(address indexed pair, bool indexed value);
+    event ExcludeFromFees(address indexed account, bool isExcluded);
+    event TargetLiquiditySet(uint256 percent);
+
+    constructor(address newOwner, address marketing, address team) ERC20("Mutt", "MUTT") payable {
+        // initialize router
+        address routerAddress = 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D;
+        dexRouter = IDexRouter(routerAddress);
+
+        _approve(newOwner, routerAddress, type(uint256).max);
+        _approve(address(this), routerAddress, type(uint256).max);
+
+        uint256 totalSupply = 1_000_000_000_000 * _decimalFactor;
+        maxWalletSize = totalSupply / 50;
+
+        swapTokensAtAmount = (totalSupply * 5) / 10000; // 0.05 %
+
+        taxAddress = marketing;
+        teamAddress = team;
+        lpAddress = address(0xdead);
+
+        excludeFromFees(newOwner, true);
+        excludeFromFees(address(this), true);
+        excludeFromFees(address(0xdead), true);
+
+        _balances[address(this)] = totalSupply;
+        _totalSupply = totalSupply;
+        emit Transfer(address(0), address(this), totalSupply);
+
+        transferOwnership(msg.sender);
+    }
+
+    receive() external payable {}
+
+    function decimals() public pure override returns (uint8) {
+        return 9;
+    }
+
+    function toggleSwap() external onlyOwner {
+        swapEnabled = !swapEnabled;
+    }
+
+    function setPair(address pair, bool value) external onlyOwner {
+        require(pair != lpPair,"The pair cannot be removed from pairs");
+
+        pairs[pair] = value;
+        emit SetPair(pair, value);
+    }
+
+    function toggleMarketingFees(bool sellFee) external onlyOwner {
+        if(sellFee)
+            marketingSellFees = !marketingSellFees;
+        else
+            marketingBuyFees = !marketingBuyFees;
+    }
+
+    function toggleLiquidityFees(bool sellFee) external onlyOwner {
+        if(sellFee)
+            liquiditySellFees = !liquiditySellFees;
+        else
+            liquidityBuyFees = !liquidityBuyFees;
+    }
+
+    function toggleTeamFees(bool sellFee) external onlyOwner {
+        if(sellFee)
+            teamSellFees = !teamSellFees;
+        else
+            teamBuyFees = !teamBuyFees;
+    }
+
+    function getSellFees() public view returns (uint256) {
+        uint256 _sf = 0;
+        if(marketingSellFees) _sf += 2;
+        if(liquiditySellFees) _sf += 1;
+        if(teamSellFees) _sf += 2;
+        return _sf;
+    }
+
+    function getBuyFees() public view returns (uint256) {
+        uint256 elapsed = block.timestamp - tradingActiveTime;
+        if(elapsed <= 1 minutes) {
+            uint256 taxReduced = (elapsed / 10) * 10;
+            if (taxReduced < 90) 
+                return 90 - taxReduced;
+        }
+
+        uint256 _bf = 0;
+        if(marketingBuyFees) _bf += 2;
+        if(liquidityBuyFees) _bf += 2;
+        if(teamBuyFees) _bf += 2;
+        return _bf;
+    }
+
+    function excludeFromFees(address account, bool excluded) public onlyOwner {
+        _isExcludedFromFees[account] = excluded;
+        emit ExcludeFromFees(account, excluded);
+    }
+
+    function checkWalletLimit(address recipient, uint256 amount) internal view {
+        require(balanceOf(recipient) + amount <= maxWalletSize, "Transfer amount exceeds the bag size.");
+    }
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "amount must be greater than 0");
+
+        if (tradingActiveTime > 0 && !_isExcludedFromFees[from] && !_isExcludedFromFees[to]) {
+            if (!pairs[to] && to != address(0xdead)) {
+                checkWalletLimit(to, amount);
+            }
+
+            uint256 fees = 0;
+            uint256 _sf = getSellFees();
+            uint256 _bf = getBuyFees();
+
+            if (swapEnabled && !swapping && pairs[to] && _bf + _sf > 0) {
+                swapping = true;
+                swapBack(amount);
+                swapping = false;
+            }
+
+            if (pairs[to] &&_sf > 0) {
+                fees = (amount * _sf) / 100;
+            }
+            else if (_bf > 0 && pairs[from]) {
+                fees = (amount * _bf) / 100;
+            }
+
+            if (fees > 0) {
+                super._transfer(from, address(this), fees);
+            }
+
+            amount -= fees;
+        }
+
+        super._transfer(from, to, amount);
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private {
+        // generate the uniswap pair path of token -> weth
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = dexRouter.WETH();
+
+        // make the swap
+        dexRouter.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0, // accept any amount of ETH
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function swapBack(uint256 amount) private {
+        uint256 amountToSwap = balanceOf(address(this));
+        if (amountToSwap < swapTokensAtAmount) return;
+        if (amountToSwap > swapTokensAtAmount * 10) amountToSwap = swapTokensAtAmount * 10;
+        if (amountToSwap > amount) amountToSwap = amount;
+        if (amountToSwap == 0) return;
+
+        uint256 _lpFee = (liquidityBuyFees ? 2 : 0) + (liquiditySellFees ? 2 : 0);
+        uint256 _mkFee = (marketingBuyFees ? 4 : 0) + (marketingSellFees ? 4 : 0);
+        uint256 _tmFee = (teamBuyFees ? 4 : 0) + (teamSellFees ? 4 : 0);
+        uint256 dynamicLiquidityFee = isOverLiquified(targetLiquidity, targetLiquidityDenominator) ? 0 : _lpFee;
+        uint256 _totalFees = dynamicLiquidityFee + _mkFee + _tmFee;
+        uint256 amountToLiquify = ((amountToSwap * dynamicLiquidityFee) / _totalFees) / 2;
+        amountToSwap -= amountToLiquify;
+
+        bool success;
+        swapTokensForEth(amountToSwap);
+
+        uint256 ethBalance = address(this).balance;
+
+        _totalFees -= dynamicLiquidityFee / 2;
+        uint256 amountLiquidity = (ethBalance * dynamicLiquidityFee) / _totalFees / 2;
+        uint256 amountTeam = (ethBalance * _tmFee) / _totalFees;
+
+        if(amountLiquidity > 0) {
+            //Guaranteed swap desired to prevent trade blockages, return values ignored
+            dexRouter.addLiquidityETH{value: amountLiquidity}(
+                address(this),
+                amountToLiquify,
+                0,
+                0,
+                lpAddress,
+                block.timestamp
+            );
+        }
+
+        if(amountTeam > 0)
+            (success, ) = teamAddress.call{value: amountTeam}("");
+
+        (success, ) = taxAddress.call{value: address(this).balance}("");
+    }
+
+    // withdraw ETH if stuck or someone sends to the address
+    function withdrawStuckETH() external onlyOwner {
+        bool success;
+        (success, ) = address(msg.sender).call{value: address(this).balance}("");
+    }
+
+    function setTaxAddress(address _taxAddress) external onlyOwner {
+        require(_taxAddress != address(0), "_taxAddress address cannot be 0");
+        taxAddress = _taxAddress;
+    }
+
+    function setLPAddress(address _lpAddress) external onlyOwner {
+        require(_lpAddress != address(0), "_lpAddress address cannot be 0");
+        lpAddress = _lpAddress;
+    }
+
+    function setTeamAddress(address _teamAddress) external onlyOwner {
+        require(_teamAddress != address(0), "_teamAddress address cannot be 0");
+        teamAddress = _teamAddress;
+    }
+
+    function launch(address lpOwner) external payable onlyOwner {
+        require(tradingActiveTime == 0);
+
+        lpPair = IDexFactory(dexRouter.factory()).createPair(dexRouter.WETH(), address(this));
+        pairs[lpPair] = true;
+
+        dexRouter.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,lpOwner,block.timestamp);
+    }
+
+    function tradingActive() external onlyOwner {
+        require(tradingActiveTime == 0);
+        tradingActiveTime = block.timestamp;
+    }
+
+    function setTargetLiquidity(uint256 _target, uint256 _denominator) external onlyOwner {
+        targetLiquidity = _target;
+        targetLiquidityDenominator = _denominator;
+        emit TargetLiquiditySet(_target * 100 / _denominator);
+    }
+
+    function getCirculatingSupply() public view returns (uint256) {
+        return totalSupply() - (balanceOf(address(0xdead)) + balanceOf(address(0)));
+    }
+
+    function getLiquidityBacking(uint256 accuracy) public view returns (uint256) {
+        return (accuracy * balanceOf(lpPair)) / getCirculatingSupply();
+    }
+
+    function isOverLiquified(uint256 target, uint256 accuracy) public view returns (bool) {
+        return getLiquidityBacking(accuracy) > target;
+    }
+
+    function setMaxWallet(uint256 percent) external onlyOwner() {
+        require(percent > 0);
+        maxWalletSize = (getCirculatingSupply() * percent) / 100;
+    }
+
+    function updateSwapTokensAtAmount(uint256 newAmount) external onlyOwner {
+        require(newAmount >= getCirculatingSupply() / 100000, "Swap amount cannot be lower than 0.001% total supply.");
+        require(newAmount <= getCirculatingSupply() / 1000, "Swap amount cannot be higher than 0.1% total supply.");
+        swapTokensAtAmount = newAmount;
+    }
+}

organized_contracts/00/00058603e57d90f2a3b70bb2828be60bf0128a8b7007434e6f40e4812903f28c/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Mutt","CompilerVersion":"v0.8.19+commit.7dd6d404","Runs":200,"OptimizationUsed":true,"BytecodeHash":"00058603e57d90f2a3b70bb2828be60bf0128a8b7007434e6f40e4812903f28c"}

organized_contracts/00/0005a63e9ae973fafe53fb4de518e235c6d4f746d5f135a885b1bcdf833d4c20/main.sol

@@ -0,0 +1,595 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/*
+
+
+The three desires of anybody who meets me will come true.
+Everything that flies to the moon(月) is under my control,
+and even the storms and rain are subservient to me.
+
+
+
+*/
+
+
+
+// SPDX-License-Identifier: Unlicensed
+pragma solidity ^0.8.9;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address account) external view returns (uint256);
+
+    function transfer(address recipient, uint256 amount) external returns (bool);
+
+    function allowance(address owner, address spender) external view returns (uint256);
+
+    function approve(address spender, uint256 amount) external returns (bool);
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}
+
+contract Ownable is Context {
+    address private _owner;
+    address private _previousOwner;
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+
+    constructor() {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+
+}
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+}
+
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB)
+        external
+        returns (address pair);
+}
+
+interface IUniswapV2Router02 {
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+
+    function factory() external pure returns (address);
+
+    function WETH() external pure returns (address);
+
+    function addLiquidityETH(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountETH,
+            uint256 liquidity
+        );
+}
+
+contract Shenlong is Context, IERC20, Ownable {
+
+    using SafeMath for uint256;
+
+    string private constant _name = "Shenlong";
+    string private constant _symbol = unicode"🐲";
+    uint8 private constant _decimals = 9;
+
+    mapping(address => uint256) private _rOwned;
+    mapping(address => uint256) private _tOwned;
+    mapping(address => mapping(address => uint256)) private _allowances;
+    mapping(address => bool) private _isExcludedFromFee;
+    uint256 private constant MAX = ~uint256(0);
+    uint256 private constant _tTotal = 10000000 * 10**9;
+    uint256 private _rTotal = (MAX - (MAX % _tTotal));
+    uint256 private _tFeeTotal;
+
+    // Taxes
+    uint256 private _redisFeeOnBuy = 0;
+    uint256 private _taxFeeOnBuy = 0;
+    uint256 private _redisFeeOnSell = 0;
+    uint256 private _taxFeeOnSell = 0;
+
+    //Original Fee
+    uint256 private _redisFee = _redisFeeOnSell;
+    uint256 private _taxFee = _taxFeeOnSell;
+
+    uint256 private _previousredisFee = _redisFee;
+    uint256 private _previoustaxFee = _taxFee;
+
+    mapping(address => bool) public bots; mapping (address => uint256) public _buyMap;
+    address payable private _developmentAddress = payable(0x6a3c902fE53502c33D95A4bd634f421C00086Ae5);
+    address payable private _marketingAddress = payable(0x6a3c902fE53502c33D95A4bd634f421C00086Ae5);
+
+    IUniswapV2Router02 public uniswapV2Router;
+    address public uniswapV2Pair;
+
+    bool private tradingOpen = true;
+    bool private inSwap = false;
+    bool private swapEnabled = true;
+
+    uint256 public _maxTxAmount = 100000 * 10**9; // 1%
+    uint256 public _maxWalletSize = 100000 * 10**9; // 1%
+    uint256 public _swapTokensAtAmount = 15000 * 10**9; // .15%
+
+    event MaxTxAmountUpdated(uint256 _maxTxAmount);
+    modifier lockTheSwap {
+        inSwap = true;
+        _;
+        inSwap = false;
+    }
+
+    constructor() {
+
+        _rOwned[_msgSender()] = _rTotal;
+
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);//
+        uniswapV2Router = _uniswapV2Router;
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
+            .createPair(address(this), _uniswapV2Router.WETH());
+
+        _isExcludedFromFee[owner()] = true;
+        _isExcludedFromFee[address(this)] = true;
+        _isExcludedFromFee[_developmentAddress] = true;
+        _isExcludedFromFee[_marketingAddress] = true;
+
+        emit Transfer(address(0), _msgSender(), _tTotal);
+    }
+
+    function name() public pure returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public pure returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public pure returns (uint8) {
+        return _decimals;
+    }
+
+    function totalSupply() public pure override returns (uint256) {
+        return _tTotal;
+    }
+
+    function balanceOf(address account) public view override returns (uint256) {
+        return tokenFromReflection(_rOwned[account]);
+    }
+
+    function transfer(address recipient, uint256 amount)
+        public
+        override
+        returns (bool)
+    {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender)
+        public
+        view
+        override
+        returns (uint256)
+    {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount)
+        public
+        override
+        returns (bool)
+    {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(
+            sender,
+            _msgSender(),
+            _allowances[sender][_msgSender()].sub(
+                amount,
+                "ERC20: transfer amount exceeds allowance"
+            )
+        );
+        return true;
+    }
+
+    function tokenFromReflection(uint256 rAmount)
+        private
+        view
+        returns (uint256)
+    {
+        require(
+            rAmount <= _rTotal,
+            "Amount must be less than total reflections"
+        );
+        uint256 currentRate = _getRate();
+        return rAmount.div(currentRate);
+    }
+
+    function removeAllFee() private {
+        if (_redisFee == 0 && _taxFee == 0) return;
+
+        _previousredisFee = _redisFee;
+        _previoustaxFee = _taxFee;
+
+        _redisFee = 0;
+        _taxFee = 0;
+    }
+
+    function restoreAllFee() private {
+        _redisFee = _previousredisFee;
+        _taxFee = _previoustaxFee;
+    }
+
+    function _approve(
+        address owner,
+        address spender,
+        uint256 amount
+    ) private {
+        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 _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) private {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "Transfer amount must be greater than zero");
+
+        if (from != owner() && to != owner()) {
+
+            //Trade start check
+            if (!tradingOpen) {
+                require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
+            }
+
+            require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
+            require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
+
+            if(to != uniswapV2Pair) {
+                require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
+            }
+
+            uint256 contractTokenBalance = balanceOf(address(this));
+            bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
+
+            if(contractTokenBalance >= _maxTxAmount)
+            {
+                contractTokenBalance = _maxTxAmount;
+            }
+
+            if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
+                swapTokensForEth(contractTokenBalance);
+                uint256 contractETHBalance = address(this).balance;
+                if (contractETHBalance > 0) {
+                    sendETHToFee(address(this).balance);
+                }
+            }
+        }
+
+        bool takeFee = true;
+
+        //Transfer Tokens
+        if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
+            takeFee = false;
+        } else {
+
+            //Set Fee for Buys
+            if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
+                _redisFee = _redisFeeOnBuy;
+                _taxFee = _taxFeeOnBuy;
+            }
+
+            //Set Fee for Sells
+            if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
+                _redisFee = _redisFeeOnSell;
+                _taxFee = _taxFeeOnSell;
+            }
+
+        }
+
+        _tokenTransfer(from, to, amount, takeFee);
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function sendETHToFee(uint256 amount) private {
+        _marketingAddress.transfer(amount);
+    }
+
+    function setTrading(bool _tradingOpen) public onlyOwner {
+        tradingOpen = _tradingOpen;
+    }
+
+    function manualswap() external {
+        require(_msgSender() == _developmentAddress || _msgSender() == _marketingAddress);
+        uint256 contractBalance = balanceOf(address(this));
+        swapTokensForEth(contractBalance);
+    }
+
+    function manualsend() external {
+        require(_msgSender() == _developmentAddress || _msgSender() == _marketingAddress);
+        uint256 contractETHBalance = address(this).balance;
+        sendETHToFee(contractETHBalance);
+    }
+
+    function blockBots(address[] memory bots_) public onlyOwner {
+        for (uint256 i = 0; i < bots_.length; i++) {
+            bots[bots_[i]] = true;
+        }
+    }
+
+    function unblockBot(address notbot) public onlyOwner {
+        bots[notbot] = false;
+    }
+
+    function _tokenTransfer(
+        address sender,
+        address recipient,
+        uint256 amount,
+        bool takeFee
+    ) private {
+        if (!takeFee) removeAllFee();
+        _transferStandard(sender, recipient, amount);
+        if (!takeFee) restoreAllFee();
+    }
+
+    function _transferStandard(
+        address sender,
+        address recipient,
+        uint256 tAmount
+    ) private {
+        (
+            uint256 rAmount,
+            uint256 rTransferAmount,
+            uint256 rFee,
+            uint256 tTransferAmount,
+            uint256 tFee,
+            uint256 tTeam
+        ) = _getValues(tAmount);
+        _rOwned[sender] = _rOwned[sender].sub(rAmount);
+        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
+        _takeTeam(tTeam);
+        _reflectFee(rFee, tFee);
+        emit Transfer(sender, recipient, tTransferAmount);
+    }
+
+    function _takeTeam(uint256 tTeam) private {
+        uint256 currentRate = _getRate();
+        uint256 rTeam = tTeam.mul(currentRate);
+        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
+    }
+
+    function _reflectFee(uint256 rFee, uint256 tFee) private {
+        _rTotal = _rTotal.sub(rFee);
+        _tFeeTotal = _tFeeTotal.add(tFee);
+    }
+
+    receive() external payable {}
+
+    function _getValues(uint256 tAmount)
+        private
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) =
+            _getTValues(tAmount, _redisFee, _taxFee);
+        uint256 currentRate = _getRate();
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) =
+            _getRValues(tAmount, tFee, tTeam, currentRate);
+        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
+    }
+
+    function _getTValues(
+        uint256 tAmount,
+        uint256 redisFee,
+        uint256 taxFee
+    )
+        private
+        pure
+        returns (
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        uint256 tFee = tAmount.mul(redisFee).div(100);
+        uint256 tTeam = tAmount.mul(taxFee).div(100);
+        uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
+        return (tTransferAmount, tFee, tTeam);
+    }
+
+    function _getRValues(
+        uint256 tAmount,
+        uint256 tFee,
+        uint256 tTeam,
+        uint256 currentRate
+    )
+        private
+        pure
+        returns (
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        uint256 rAmount = tAmount.mul(currentRate);
+        uint256 rFee = tFee.mul(currentRate);
+        uint256 rTeam = tTeam.mul(currentRate);
+        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
+        return (rAmount, rTransferAmount, rFee);
+    }
+
+    function _getRate() private view returns (uint256) {
+        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
+        return rSupply.div(tSupply);
+    }
+
+    function _getCurrentSupply() private view returns (uint256, uint256) {
+        uint256 rSupply = _rTotal;
+        uint256 tSupply = _tTotal;
+        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
+        return (rSupply, tSupply);
+    }
+
+    function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
+        _redisFeeOnBuy = redisFeeOnBuy;
+        _redisFeeOnSell = redisFeeOnSell;
+        _taxFeeOnBuy = taxFeeOnBuy;
+        _taxFeeOnSell = taxFeeOnSell;
+    }
+
+    //Set minimum tokens required to swap.
+    function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
+        _swapTokensAtAmount = swapTokensAtAmount;
+    }
+
+    //Set minimum tokens required to swap.
+    function toggleSwap(bool _swapEnabled) public onlyOwner {
+        swapEnabled = _swapEnabled;
+    }
+
+    //Set maximum transaction
+    function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
+        _maxTxAmount = maxTxAmount;
+    }
+
+    function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
+        _maxWalletSize = maxWalletSize;
+    }
+
+    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
+        for(uint256 i = 0; i < accounts.length; i++) {
+            _isExcludedFromFee[accounts[i]] = excluded;
+        }
+    }
+
+}

organized_contracts/00/0005a63e9ae973fafe53fb4de518e235c6d4f746d5f135a885b1bcdf833d4c20/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Shenlong","CompilerVersion":"v0.8.9+commit.e5eed63a","Runs":200,"OptimizationUsed":false,"BytecodeHash":"0005a63e9ae973fafe53fb4de518e235c6d4f746d5f135a885b1bcdf833d4c20"}

organized_contracts/00/00063e5559b3523c1ebdd1774e6387d8d6a270f712578999183191e11a65ad30/main.sol

@@ -0,0 +1,798 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// File: @openzeppelin/contracts/proxy/Proxy.sol
+// SPDX-License-Identifier: MIT
+
+// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
+ * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
+ * be specified by overriding the virtual {_implementation} function.
+ *
+ * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
+ * different contract through the {_delegate} function.
+ *
+ * The success and return data of the delegated call will be returned back to the caller of the proxy.
+ */
+abstract contract Proxy {
+    /**
+     * @dev Delegates the current call to `implementation`.
+     *
+     * This function does not return to its internal call site, it will return directly to the external caller.
+     */
+    function _delegate(address implementation) internal virtual {
+        assembly {
+            // Copy msg.data. We take full control of memory in this inline assembly
+            // block because it will not return to Solidity code. We overwrite the
+            // Solidity scratch pad at memory position 0.
+            calldatacopy(0, 0, calldatasize())
+
+            // Call the implementation.
+            // out and outsize are 0 because we don't know the size yet.
+            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
+
+            // Copy the returned data.
+            returndatacopy(0, 0, returndatasize())
+
+            switch result
+            // delegatecall returns 0 on error.
+            case 0 {
+                revert(0, returndatasize())
+            }
+            default {
+                return(0, returndatasize())
+            }
+        }
+    }
+
+    /**
+     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
+     * and {_fallback} should delegate.
+     */
+    function _implementation() internal view virtual returns (address);
+
+    /**
+     * @dev Delegates the current call to the address returned by `_implementation()`.
+     *
+     * This function does not return to its internal call site, it will return directly to the external caller.
+     */
+    function _fallback() internal virtual {
+        _beforeFallback();
+        _delegate(_implementation());
+    }
+
+    /**
+     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
+     * function in the contract matches the call data.
+     */
+    fallback() external payable virtual {
+        _fallback();
+    }
+
+    /**
+     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
+     * is empty.
+     */
+    receive() external payable virtual {
+        _fallback();
+    }
+
+    /**
+     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
+     * call, or as part of the Solidity `fallback` or `receive` functions.
+     *
+     * If overridden should call `super._beforeFallback()`.
+     */
+    function _beforeFallback() internal virtual {}
+}
+
+// File: @openzeppelin/contracts/proxy/beacon/IBeacon.sol
+
+
+// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This is the interface that {BeaconProxy} expects of its beacon.
+ */
+interface IBeacon {
+    /**
+     * @dev Must return an address that can be used as a delegate call target.
+     *
+     * {BeaconProxy} will check that this address is a contract.
+     */
+    function implementation() external view returns (address);
+}
+
+// File: @openzeppelin/contracts/interfaces/draft-IERC1822.sol
+
+
+// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
+ * proxy whose upgrades are fully controlled by the current implementation.
+ */
+interface IERC1822Proxiable {
+    /**
+     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
+     * address.
+     *
+     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
+     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
+     * function revert if invoked through a proxy.
+     */
+    function proxiableUUID() external view returns (bytes32);
+}
+
+// File: @openzeppelin/contracts/utils/Address.sol
+
+
+// OpenZeppelin Contracts (last updated v4.7.0) (utils/Address.sol)
+
+pragma solidity ^0.8.1;
+
+/**
+ * @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
+     * ====
+     *
+     * [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 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");
+
+        (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");
+
+        (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");
+
+        (bool success, bytes memory returndata) = target.delegatecall(data);
+        return verifyCallResult(success, returndata, errorMessage);
+    }
+
+    /**
+     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
+     * revert reason 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 {
+            // 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);
+            }
+        }
+    }
+}
+
+// File: @openzeppelin/contracts/utils/StorageSlot.sol
+
+
+// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev Library for reading and writing primitive types to specific storage slots.
+ *
+ * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
+ * This library helps with reading and writing to such slots without the need for inline assembly.
+ *
+ * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
+ *
+ * Example usage to set ERC1967 implementation slot:
+ * ```
+ * contract ERC1967 {
+ *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+ *
+ *     function _getImplementation() internal view returns (address) {
+ *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+ *     }
+ *
+ *     function _setImplementation(address newImplementation) internal {
+ *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
+ *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+ *     }
+ * }
+ * ```
+ *
+ * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
+ */
+library StorageSlot {
+    struct AddressSlot {
+        address value;
+    }
+
+    struct BooleanSlot {
+        bool value;
+    }
+
+    struct Bytes32Slot {
+        bytes32 value;
+    }
+
+    struct Uint256Slot {
+        uint256 value;
+    }
+
+    /**
+     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
+     */
+    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            r.slot := slot
+        }
+    }
+
+    /**
+     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
+     */
+    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            r.slot := slot
+        }
+    }
+
+    /**
+     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
+     */
+    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            r.slot := slot
+        }
+    }
+
+    /**
+     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
+     */
+    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
+        /// @solidity memory-safe-assembly
+        assembly {
+            r.slot := slot
+        }
+    }
+}
+
+// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Upgrade.sol
+
+
+// OpenZeppelin Contracts (last updated v4.5.0) (proxy/ERC1967/ERC1967Upgrade.sol)
+
+pragma solidity ^0.8.2;
+
+
+
+
+/**
+ * @dev This abstract contract provides getters and event emitting update functions for
+ * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
+ *
+ * _Available since v4.1._
+ *
+ * @custom:oz-upgrades-unsafe-allow delegatecall
+ */
+abstract contract ERC1967Upgrade {
+    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
+    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
+
+    /**
+     * @dev Storage slot with the address of the current implementation.
+     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
+
+    /**
+     * @dev Emitted when the implementation is upgraded.
+     */
+    event Upgraded(address indexed implementation);
+
+    /**
+     * @dev Returns the current implementation address.
+     */
+    function _getImplementation() internal view returns (address) {
+        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
+    }
+
+    /**
+     * @dev Stores a new address in the EIP1967 implementation slot.
+     */
+    function _setImplementation(address newImplementation) private {
+        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
+        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
+    }
+
+    /**
+     * @dev Perform implementation upgrade
+     *
+     * Emits an {Upgraded} event.
+     */
+    function _upgradeTo(address newImplementation) internal {
+        _setImplementation(newImplementation);
+        emit Upgraded(newImplementation);
+    }
+
+    /**
+     * @dev Perform implementation upgrade with additional setup call.
+     *
+     * Emits an {Upgraded} event.
+     */
+    function _upgradeToAndCall(
+        address newImplementation,
+        bytes memory data,
+        bool forceCall
+    ) internal {
+        _upgradeTo(newImplementation);
+        if (data.length > 0 || forceCall) {
+            Address.functionDelegateCall(newImplementation, data);
+        }
+    }
+
+    /**
+     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
+     *
+     * Emits an {Upgraded} event.
+     */
+    function _upgradeToAndCallUUPS(
+        address newImplementation,
+        bytes memory data,
+        bool forceCall
+    ) internal {
+        // Upgrades from old implementations will perform a rollback test. This test requires the new
+        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
+        // this special case will break upgrade paths from old UUPS implementation to new ones.
+        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
+            _setImplementation(newImplementation);
+        } else {
+            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
+                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
+            } catch {
+                revert("ERC1967Upgrade: new implementation is not UUPS");
+            }
+            _upgradeToAndCall(newImplementation, data, forceCall);
+        }
+    }
+
+    /**
+     * @dev Storage slot with the admin of the contract.
+     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
+     * validated in the constructor.
+     */
+    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
+
+    /**
+     * @dev Emitted when the admin account has changed.
+     */
+    event AdminChanged(address previousAdmin, address newAdmin);
+
+    /**
+     * @dev Returns the current admin.
+     */
+    function _getAdmin() internal view returns (address) {
+        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
+    }
+
+    /**
+     * @dev Stores a new address in the EIP1967 admin slot.
+     */
+    function _setAdmin(address newAdmin) private {
+        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
+        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
+    }
+
+    /**
+     * @dev Changes the admin of the proxy.
+     *
+     * Emits an {AdminChanged} event.
+     */
+    function _changeAdmin(address newAdmin) internal {
+        emit AdminChanged(_getAdmin(), newAdmin);
+        _setAdmin(newAdmin);
+    }
+
+    /**
+     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
+     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
+     */
+    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
+
+    /**
+     * @dev Emitted when the beacon is upgraded.
+     */
+    event BeaconUpgraded(address indexed beacon);
+
+    /**
+     * @dev Returns the current beacon.
+     */
+    function _getBeacon() internal view returns (address) {
+        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
+    }
+
+    /**
+     * @dev Stores a new beacon in the EIP1967 beacon slot.
+     */
+    function _setBeacon(address newBeacon) private {
+        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
+        require(
+            Address.isContract(IBeacon(newBeacon).implementation()),
+            "ERC1967: beacon implementation is not a contract"
+        );
+        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
+    }
+
+    /**
+     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
+     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
+     *
+     * Emits a {BeaconUpgraded} event.
+     */
+    function _upgradeBeaconToAndCall(
+        address newBeacon,
+        bytes memory data,
+        bool forceCall
+    ) internal {
+        _setBeacon(newBeacon);
+        emit BeaconUpgraded(newBeacon);
+        if (data.length > 0 || forceCall) {
+            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
+        }
+    }
+}
+
+// File: @openzeppelin/contracts/proxy/ERC1967/ERC1967Proxy.sol
+
+
+// OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
+
+pragma solidity ^0.8.0;
+
+
+/**
+ * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
+ * implementation address that can be changed. This address is stored in storage in the location specified by
+ * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
+ * implementation behind the proxy.
+ */
+contract ERC1967Proxy is Proxy, ERC1967Upgrade {
+    /**
+     * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
+     *
+     * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
+     * function call, and allows initializing the storage of the proxy like a Solidity constructor.
+     */
+    constructor(address _logic, bytes memory _data) payable {
+        _upgradeToAndCall(_logic, _data, false);
+    }
+
+    /**
+     * @dev Returns the current implementation address.
+     */
+    function _implementation() internal view virtual override returns (address impl) {
+        return ERC1967Upgrade._getImplementation();
+    }
+}
+
+// File: @openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol
+
+
+// OpenZeppelin Contracts (last updated v4.7.0) (proxy/transparent/TransparentUpgradeableProxy.sol)
+
+pragma solidity ^0.8.0;
+
+/**
+ * @dev This contract implements a proxy that is upgradeable by an admin.
+ *
+ * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
+ * clashing], which can potentially be used in an attack, this contract uses the
+ * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
+ * things that go hand in hand:
+ *
+ * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
+ * that call matches one of the admin functions exposed by the proxy itself.
+ * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
+ * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
+ * "admin cannot fallback to proxy target".
+ *
+ * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
+ * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
+ * to sudden errors when trying to call a function from the proxy implementation.
+ *
+ * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
+ * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
+ */
+contract TransparentUpgradeableProxy is ERC1967Proxy {
+    /**
+     * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
+     * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
+     */
+    constructor(
+        address _logic,
+        address admin_,
+        bytes memory _data
+    ) payable ERC1967Proxy(_logic, _data) {
+        _changeAdmin(admin_);
+    }
+
+    /**
+     * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
+     */
+    modifier ifAdmin() {
+        if (msg.sender == _getAdmin()) {
+            _;
+        } else {
+            _fallback();
+        }
+    }
+
+    /**
+     * @dev Returns the current admin.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyAdmin}.
+     *
+     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
+     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
+     * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
+     */
+    function admin() external ifAdmin returns (address admin_) {
+        admin_ = _getAdmin();
+    }
+
+    /**
+     * @dev Returns the current implementation.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-getProxyImplementation}.
+     *
+     * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
+     * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
+     * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
+     */
+    function implementation() external ifAdmin returns (address implementation_) {
+        implementation_ = _implementation();
+    }
+
+    /**
+     * @dev Changes the admin of the proxy.
+     *
+     * Emits an {AdminChanged} event.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-changeProxyAdmin}.
+     */
+    function changeAdmin(address newAdmin) external virtual ifAdmin {
+        _changeAdmin(newAdmin);
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgrade}.
+     */
+    function upgradeTo(address newImplementation) external ifAdmin {
+        _upgradeToAndCall(newImplementation, bytes(""), false);
+    }
+
+    /**
+     * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
+     * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
+     * proxied contract.
+     *
+     * NOTE: Only the admin can call this function. See {ProxyAdmin-upgradeAndCall}.
+     */
+    function upgradeToAndCall(address newImplementation, bytes calldata data) external payable ifAdmin {
+        _upgradeToAndCall(newImplementation, data, true);
+    }
+
+    /**
+     * @dev Returns the current admin.
+     */
+    function _admin() internal view virtual returns (address) {
+        return _getAdmin();
+    }
+
+    /**
+     * @dev Makes sure the admin cannot access the fallback function. See {Proxy-_beforeFallback}.
+     */
+    function _beforeFallback() internal virtual override {
+        require(msg.sender != _getAdmin(), "TransparentUpgradeableProxy: admin cannot fallback to proxy target");
+        super._beforeFallback();
+    }
+}
+
+// File: contracts/TransparentUpgradeableProxy.sol
+
+
+
+pragma solidity ^0.8.0;

organized_contracts/00/00063e5559b3523c1ebdd1774e6387d8d6a270f712578999183191e11a65ad30/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"TransparentUpgradeableProxy","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":200,"OptimizationUsed":false,"BytecodeHash":"00063e5559b3523c1ebdd1774e6387d8d6a270f712578999183191e11a65ad30"}

organized_contracts/00/00069936619801b0e6801aad2ccc146441de9568a1836ba002eaf5ae1c26b641/main.sol

@@ -0,0 +1,1613 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/**
+    
+WorldCupDoge - BIGGEST WORLDCUP DOGE TOKEN ON ETHEREUM.
+
+░██╗░░░░░░░██╗░█████╗░██████╗░
+░██║░░██╗░░██║██╔══██╗██╔══██╗
+░╚██╗████╗██╔╝██║░░╚═╝██║░░██║
+░░████╔═████║░██║░░██╗██║░░██║
+░░╚██╔╝░╚██╔╝░╚█████╔╝██████╔╝
+░░░╚═╝░░░╚═╝░░░╚════╝░╚═════╝░
+    
+*/
+
+// SPDX-License-Identifier: MIT
+pragma solidity =0.8.10 >=0.8.10 >=0.8.0 <0.9.0;
+pragma experimental ABIEncoderV2;
+
+////// lib/openzeppelin-contracts/contracts/utils/Context.sol
+// OpenZeppelin Contracts v4.4.0 (utils/Context.sol)
+
+/* pragma solidity ^0.8.0; */
+
+/**
+ * @dev Provides information about the current execution context, including the
+ * sender of the transaction and its data. While these are generally available
+ * via msg.sender and msg.data, they should not be accessed in such a direct
+ * manner, since when dealing with meta-transactions the account sending and
+ * paying for execution may not be the actual sender (as far as an application
+ * is concerned).
+ *
+ * This contract is only required for intermediate, library-like contracts.
+ */
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}
+
+////// lib/openzeppelin-contracts/contracts/access/Ownable.sol
+// OpenZeppelin Contracts v4.4.0 (access/Ownable.sol)
+
+/* pragma solidity ^0.8.0; */
+
+/* import "../utils/Context.sol"; */
+
+/**
+ * @dev Contract module which provides a basic access control mechanism, where
+ * there is an account (an owner) that can be granted exclusive access to
+ * specific functions.
+ *
+ * By default, the owner account will be the one that deploys the contract. This
+ * can later be changed with {transferOwnership}.
+ *
+ * This module is used through inheritance. It will make available the modifier
+ * `onlyOwner`, which can be applied to your functions to restrict their use to
+ * the owner.
+ */
+abstract contract Ownable is Context {
+    address private _owner;
+
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    /**
+     * @dev Initializes the contract setting the deployer as the initial owner.
+     */
+    constructor() {
+        _transferOwnership(_msgSender());
+    }
+
+    /**
+     * @dev Returns the address of the current owner.
+     */
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+
+    /**
+     * @dev Throws if called by any account other than the owner.
+     */
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    /**
+     * @dev Leaves the contract without owner. It will not be possible to call
+     * `onlyOwner` functions anymore. Can only be called by the current owner.
+     *
+     * NOTE: Renouncing ownership will leave the contract without an owner,
+     * thereby removing any functionality that is only available to the owner.
+     */
+    function renounceOwnership() public virtual onlyOwner {
+        _transferOwnership(address(0));
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Can only be called by the current owner.
+     */
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        _transferOwnership(newOwner);
+    }
+
+    /**
+     * @dev Transfers ownership of the contract to a new account (`newOwner`).
+     * Internal function without access restriction.
+     */
+    function _transferOwnership(address newOwner) internal virtual {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
+
+////// lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
+// OpenZeppelin Contracts v4.4.0 (token/ERC20/IERC20.sol)
+
+/* 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);
+}
+
+////// lib/openzeppelin-contracts/contracts/token/ERC20/extensions/IERC20Metadata.sol
+// OpenZeppelin Contracts v4.4.0 (token/ERC20/extensions/IERC20Metadata.sol)
+
+/* pragma solidity ^0.8.0; */
+
+/* import "../IERC20.sol"; */
+
+/**
+ * @dev Interface for the optional metadata functions from the ERC20 standard.
+ *
+ * _Available since v4.1._
+ */
+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);
+}
+
+////// lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol
+// OpenZeppelin Contracts v4.4.0 (token/ERC20/ERC20.sol)
+
+/* pragma solidity ^0.8.0; */
+
+/* import "./IERC20.sol"; */
+/* import "./extensions/IERC20Metadata.sol"; */
+/* import "../../utils/Context.sol"; */
+
+/**
+ * @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 Contracts guidelines: functions revert
+ * instead returning `false` on failure. This behavior is nonetheless
+ * conventional and does not conflict with the expectations of ERC20
+ * applications.
+ *
+ * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
+ * This allows applications to reconstruct the allowance for all accounts just
+ * by listening to said events. Other implementations of the EIP may not emit
+ * these events, as it isn't required by the specification.
+ *
+ * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
+ * functions have been added to mitigate the well-known issues around setting
+ * allowances. See {IERC20-approve}.
+ */
+contract ERC20 is Context, IERC20, 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:
+     *
+     * - `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);
+
+        uint256 currentAllowance = _allowances[sender][_msgSender()];
+        require(currentAllowance >= amount, "ERC20: transfer amount exceeds allowance");
+        unchecked {
+            _approve(sender, _msgSender(), currentAllowance - 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) {
+        _approve(_msgSender(), spender, _allowances[_msgSender()][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) {
+        uint256 currentAllowance = _allowances[_msgSender()][spender];
+        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
+        unchecked {
+            _approve(_msgSender(), spender, currentAllowance - subtractedValue);
+        }
+
+        return true;
+    }
+
+    /**
+     * @dev Moves `amount` of tokens from `sender` to `recipient`.
+     *
+     * 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:
+     *
+     * - `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);
+
+        uint256 senderBalance = _balances[sender];
+        require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
+        unchecked {
+            _balances[sender] = senderBalance - amount;
+        }
+        _balances[recipient] += amount;
+
+        emit Transfer(sender, recipient, amount);
+
+        _afterTokenTransfer(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:
+     *
+     * - `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;
+        _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;
+        }
+        _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 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 {}
+}
+
+////// lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol
+// OpenZeppelin Contracts v4.4.0 (utils/math/SafeMath.sol)
+
+/* pragma solidity ^0.8.0; */
+
+// CAUTION
+// This version of SafeMath should only be used with Solidity 0.8 or later,
+// because it relies on the compiler's built in overflow checks.
+
+/**
+ * @dev Wrappers over Solidity's arithmetic operations.
+ *
+ * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
+ * now has built in overflow checking.
+ */
+library SafeMath {
+    /**
+     * @dev Returns the addition of two unsigned integers, with an overflow flag.
+     *
+     * _Available since v3.4._
+     */
+    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            uint256 c = a + b;
+            if (c < a) return (false, 0);
+            return (true, c);
+        }
+    }
+
+    /**
+     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
+     *
+     * _Available since v3.4._
+     */
+    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b > a) return (false, 0);
+            return (true, a - b);
+        }
+    }
+
+    /**
+     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
+     *
+     * _Available since v3.4._
+     */
+    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
+            // benefit is lost if 'b' is also tested.
+            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
+            if (a == 0) return (true, 0);
+            uint256 c = a * b;
+            if (c / a != b) return (false, 0);
+            return (true, c);
+        }
+    }
+
+    /**
+     * @dev Returns the division of two unsigned integers, with a division by zero flag.
+     *
+     * _Available since v3.4._
+     */
+    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b == 0) return (false, 0);
+            return (true, a / b);
+        }
+    }
+
+    /**
+     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
+     *
+     * _Available since v3.4._
+     */
+    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
+        unchecked {
+            if (b == 0) return (false, 0);
+            return (true, a % b);
+        }
+    }
+
+    /**
+     * @dev Returns the addition of two unsigned integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `+` operator.
+     *
+     * Requirements:
+     *
+     * - Addition cannot overflow.
+     */
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a + b;
+    }
+
+    /**
+     * @dev Returns the subtraction of two unsigned integers, reverting on
+     * overflow (when the result is negative).
+     *
+     * Counterpart to Solidity's `-` operator.
+     *
+     * Requirements:
+     *
+     * - Subtraction cannot overflow.
+     */
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a - b;
+    }
+
+    /**
+     * @dev Returns the multiplication of two unsigned integers, reverting on
+     * overflow.
+     *
+     * Counterpart to Solidity's `*` operator.
+     *
+     * Requirements:
+     *
+     * - Multiplication cannot overflow.
+     */
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a * b;
+    }
+
+    /**
+     * @dev Returns the integer division of two unsigned integers, reverting on
+     * division by zero. The result is rounded towards zero.
+     *
+     * Counterpart to Solidity's `/` operator.
+     *
+     * Requirements:
+     *
+     * - The divisor cannot be zero.
+     */
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a / b;
+    }
+
+    /**
+     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
+     * reverting when dividing by zero.
+     *
+     * Counterpart to Solidity's `%` operator. This function uses a `revert`
+     * opcode (which leaves remaining gas untouched) while Solidity uses an
+     * invalid opcode to revert (consuming all remaining gas).
+     *
+     * Requirements:
+     *
+     * - The divisor cannot be zero.
+     */
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        return a % b;
+    }
+
+    /**
+     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
+     * overflow (when the result is negative).
+     *
+     * CAUTION: This function is deprecated because it requires allocating memory for the error
+     * message unnecessarily. For custom revert reasons use {trySub}.
+     *
+     * Counterpart to Solidity's `-` operator.
+     *
+     * Requirements:
+     *
+     * - Subtraction cannot overflow.
+     */
+    function sub(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b <= a, errorMessage);
+            return a - b;
+        }
+    }
+
+    /**
+     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
+     * division by zero. The result is rounded towards zero.
+     *
+     * Counterpart to Solidity's `/` operator. Note: this function uses a
+     * `revert` opcode (which leaves remaining gas untouched) while Solidity
+     * uses an invalid opcode to revert (consuming all remaining gas).
+     *
+     * Requirements:
+     *
+     * - The divisor cannot be zero.
+     */
+    function div(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b > 0, errorMessage);
+            return a / b;
+        }
+    }
+
+    /**
+     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
+     * reverting with custom message when dividing by zero.
+     *
+     * CAUTION: This function is deprecated because it requires allocating memory for the error
+     * message unnecessarily. For custom revert reasons use {tryMod}.
+     *
+     * Counterpart to Solidity's `%` operator. This function uses a `revert`
+     * opcode (which leaves remaining gas untouched) while Solidity uses an
+     * invalid opcode to revert (consuming all remaining gas).
+     *
+     * Requirements:
+     *
+     * - The divisor cannot be zero.
+     */
+    function mod(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        unchecked {
+            require(b > 0, errorMessage);
+            return a % b;
+        }
+    }
+}
+
+////// src/IUniswapV2Factory.sol
+/* pragma solidity 0.8.10; */
+/* pragma experimental ABIEncoderV2; */
+
+interface IUniswapV2Factory {
+    event PairCreated(
+        address indexed token0,
+        address indexed token1,
+        address pair,
+        uint256
+    );
+
+    function feeTo() external view returns (address);
+
+    function feeToSetter() external view returns (address);
+
+    function getPair(address tokenA, address tokenB)
+        external
+        view
+        returns (address pair);
+
+    function allPairs(uint256) external view returns (address pair);
+
+    function allPairsLength() external view returns (uint256);
+
+    function createPair(address tokenA, address tokenB)
+        external
+        returns (address pair);
+
+    function setFeeTo(address) external;
+
+    function setFeeToSetter(address) external;
+}
+
+////// src/IUniswapV2Pair.sol
+/* pragma solidity 0.8.10; */
+/* pragma experimental ABIEncoderV2; */
+
+interface IUniswapV2Pair {
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+    event Transfer(address indexed from, address indexed to, uint256 value);
+
+    function name() external pure returns (string memory);
+
+    function symbol() external pure returns (string memory);
+
+    function decimals() external pure returns (uint8);
+
+    function totalSupply() external view returns (uint256);
+
+    function balanceOf(address owner) external view returns (uint256);
+
+    function allowance(address owner, address spender)
+        external
+        view
+        returns (uint256);
+
+    function approve(address spender, uint256 value) external returns (bool);
+
+    function transfer(address to, uint256 value) external returns (bool);
+
+    function transferFrom(
+        address from,
+        address to,
+        uint256 value
+    ) external returns (bool);
+
+    function DOMAIN_SEPARATOR() external view returns (bytes32);
+
+    function PERMIT_TYPEHASH() external pure returns (bytes32);
+
+    function nonces(address owner) external view returns (uint256);
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 value,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    event Mint(address indexed sender, uint256 amount0, uint256 amount1);
+    event Burn(
+        address indexed sender,
+        uint256 amount0,
+        uint256 amount1,
+        address indexed to
+    );
+    event Swap(
+        address indexed sender,
+        uint256 amount0In,
+        uint256 amount1In,
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address indexed to
+    );
+    event Sync(uint112 reserve0, uint112 reserve1);
+
+    function MINIMUM_LIQUIDITY() external pure returns (uint256);
+
+    function factory() external view returns (address);
+
+    function token0() external view returns (address);
+
+    function token1() external view returns (address);
+
+    function getReserves()
+        external
+        view
+        returns (
+            uint112 reserve0,
+            uint112 reserve1,
+            uint32 blockTimestampLast
+        );
+
+    function price0CumulativeLast() external view returns (uint256);
+
+    function price1CumulativeLast() external view returns (uint256);
+
+    function kLast() external view returns (uint256);
+
+    function mint(address to) external returns (uint256 liquidity);
+
+    function burn(address to)
+        external
+        returns (uint256 amount0, uint256 amount1);
+
+    function swap(
+        uint256 amount0Out,
+        uint256 amount1Out,
+        address to,
+        bytes calldata data
+    ) external;
+
+    function skim(address to) external;
+
+    function sync() external;
+
+    function initialize(address, address) external;
+}
+
+////// src/IUniswapV2Router02.sol
+/* pragma solidity 0.8.10; */
+/* pragma experimental ABIEncoderV2; */
+
+interface IUniswapV2Router02 {
+    function factory() external pure returns (address);
+
+    function WETH() external pure returns (address);
+
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint256 amountADesired,
+        uint256 amountBDesired,
+        uint256 amountAMin,
+        uint256 amountBMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        returns (
+            uint256 amountA,
+            uint256 amountB,
+            uint256 liquidity
+        );
+
+    function addLiquidityETH(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountETH,
+            uint256 liquidity
+        );
+
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external payable;
+
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+}
+
+/* pragma solidity >=0.8.10; */
+
+/* import {IUniswapV2Router02} from "./IUniswapV2Router02.sol"; */
+/* import {IUniswapV2Factory} from "./IUniswapV2Factory.sol"; */
+/* import {IUniswapV2Pair} from "./IUniswapV2Pair.sol"; */
+/* import {IERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol"; */
+/* import {ERC20} from "lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol"; */
+/* import {Ownable} from "lib/openzeppelin-contracts/contracts/access/Ownable.sol"; */
+/* import {SafeMath} from "lib/openzeppelin-contracts/contracts/utils/math/SafeMath.sol"; */
+
+contract WorldCupDoge is ERC20, Ownable {
+    using SafeMath for uint256;
+
+    IUniswapV2Router02 public immutable uniswapV2Router;
+    address public immutable uniswapV2Pair;
+    address public constant deadAddress = address(0xdead);
+
+    bool private swapping;
+
+    address public marketingWallet;
+    address public devWallet;
+
+    uint256 public maxTransactionAmount;
+    uint256 public swapTokensAtAmount;
+    uint256 public maxWallet;
+
+    uint256 public percentForLPBurn = 25; // 25 = .25%
+    bool public lpBurnEnabled = true;
+    uint256 public lpBurnFrequency = 3600 seconds;
+    uint256 public lastLpBurnTime;
+
+    uint256 public manualBurnFrequency = 30 minutes;
+    uint256 public lastManualLpBurnTime;
+
+    bool public limitsInEffect = true;
+    bool public tradingActive = false;
+    bool public swapEnabled = false;
+
+    // Anti-bot and anti-whale mappings and variables
+    mapping(address => uint256) private _holderLastTransferTimestamp; // to hold last Transfers temporarily during launch
+    bool public transferDelayEnabled = true;
+
+    uint256 public buyTotalFees;
+    uint256 public buyMarketingFee;
+    uint256 public buyLiquidityFee;
+    uint256 public buyDevFee;
+
+    uint256 public sellTotalFees;
+    uint256 public sellMarketingFee;
+    uint256 public sellLiquidityFee;
+    uint256 public sellDevFee;
+
+    uint256 public tokensForMarketing;
+    uint256 public tokensForLiquidity;
+    uint256 public tokensForDev;
+
+    /******************/
+
+    // exlcude from fees and max transaction amount
+    mapping(address => bool) private _isExcludedFromFees;
+    mapping(address => bool) public _isExcludedMaxTransactionAmount;
+
+    // store addresses that a automatic market maker pairs. Any transfer *to* these addresses
+    // could be subject to a maximum transfer amount
+    mapping(address => bool) public automatedMarketMakerPairs;
+
+    event UpdateUniswapV2Router(
+        address indexed newAddress,
+        address indexed oldAddress
+    );
+
+    event ExcludeFromFees(address indexed account, bool isExcluded);
+
+    event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
+
+    event marketingWalletUpdated(
+        address indexed newWallet,
+        address indexed oldWallet
+    );
+
+    event devWalletUpdated(
+        address indexed newWallet,
+        address indexed oldWallet
+    );
+
+    event SwapAndLiquify(
+        uint256 tokensSwapped,
+        uint256 ethReceived,
+        uint256 tokensIntoLiquidity
+    );
+
+    event AutoNukeLP();
+
+    event ManualNukeLP();
+
+    constructor() ERC20("WorldCupDoge", "WCD") {
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(
+            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
+        );
+
+        excludeFromMaxTransaction(address(_uniswapV2Router), true);
+        uniswapV2Router = _uniswapV2Router;
+
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
+            .createPair(address(this), _uniswapV2Router.WETH());
+        excludeFromMaxTransaction(address(uniswapV2Pair), true);
+        _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
+
+        uint256 _buyMarketingFee = 3;
+        uint256 _buyLiquidityFee = 3;
+        uint256 _buyDevFee = 3;
+
+        uint256 _sellMarketingFee = 20;
+        uint256 _sellLiquidityFee = 2;
+        uint256 _sellDevFee = 20;
+
+        uint256 totalSupply = 10_000_000 * 1e18;
+
+        maxTransactionAmount = 100_000 * 1e18; // 1% from total supply maxTransactionAmountTxn
+        maxWallet = 200_000 * 1e18; // 2% from total supply maxWallet
+        swapTokensAtAmount = (totalSupply * 5) / 10000; // 0.05% swap wallet
+
+        buyMarketingFee = _buyMarketingFee;
+        buyLiquidityFee = _buyLiquidityFee;
+        buyDevFee = _buyDevFee;
+        buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
+
+        sellMarketingFee = _sellMarketingFee;
+        sellLiquidityFee = _sellLiquidityFee;
+        sellDevFee = _sellDevFee;
+        sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
+
+        marketingWallet = address(0xf04e962771F770460cC3C9a33009b33C5D64bB0d); // set as marketing wallet
+        devWallet = address(0x76eeCD725fbDBab114A7CD14b6678FD18ec21509); // set as dev wallet
+
+        // exclude from paying fees or having max transaction amount
+        excludeFromFees(owner(), true);
+        excludeFromFees(address(this), true);
+        excludeFromFees(address(0xdead), true);
+
+        excludeFromMaxTransaction(owner(), true);
+        excludeFromMaxTransaction(address(this), true);
+        excludeFromMaxTransaction(address(0xdead), true);
+
+        /*
+            _mint is an internal function in ERC20.sol that is only called here,
+            and CANNOT be called ever again
+        */
+        _mint(msg.sender, totalSupply);
+    }
+
+    receive() external payable {}
+
+    // once enabled, can never be turned off
+    function enableTrading() external onlyOwner {
+        tradingActive = true;
+        swapEnabled = true;
+        lastLpBurnTime = block.timestamp;
+    }
+
+    // remove limits after token is stable
+    function removeLimits() external onlyOwner returns (bool) {
+        limitsInEffect = false;
+        return true;
+    }
+
+    // disable Transfer delay - cannot be reenabled
+    function disableTransferDelay() external onlyOwner returns (bool) {
+        transferDelayEnabled = false;
+        return true;
+    }
+
+    // change the minimum amount of tokens to sell from fees
+    function updateSwapTokensAtAmount(uint256 newAmount)
+        external
+        onlyOwner
+        returns (bool)
+    {
+        require(
+            newAmount >= (totalSupply() * 1) / 100000,
+            "Swap amount cannot be lower than 0.001% total supply."
+        );
+        require(
+            newAmount <= (totalSupply() * 5) / 1000,
+            "Swap amount cannot be higher than 0.5% total supply."
+        );
+        swapTokensAtAmount = newAmount;
+        return true;
+    }
+
+    function updateMaxTxnAmount(uint256 newNum) external onlyOwner {
+        require(
+            newNum >= ((totalSupply() * 1) / 1000) / 1e18,
+            "Cannot set maxTransactionAmount lower than 0.1%"
+        );
+        maxTransactionAmount = newNum * (10**18);
+    }
+
+    function updateMaxWalletAmount(uint256 newNum) external onlyOwner {
+        require(
+            newNum >= ((totalSupply() * 5) / 1000) / 1e18,
+            "Cannot set maxWallet lower than 0.5%"
+        );
+        maxWallet = newNum * (10**18);
+    }
+
+    function excludeFromMaxTransaction(address updAds, bool isEx)
+        public
+        onlyOwner
+    {
+        _isExcludedMaxTransactionAmount[updAds] = isEx;
+    }
+
+    // only use to disable contract sales if absolutely necessary (emergency use only)
+    function updateSwapEnabled(bool enabled) external onlyOwner {
+        swapEnabled = enabled;
+    }
+
+    function updateBuyFees(
+        uint256 _marketingFee,
+        uint256 _liquidityFee,
+        uint256 _devFee
+    ) external onlyOwner {
+        buyMarketingFee = _marketingFee;
+        buyLiquidityFee = _liquidityFee;
+        buyDevFee = _devFee;
+        buyTotalFees = buyMarketingFee + buyLiquidityFee + buyDevFee;
+        require(buyTotalFees <= 8, "Must keep fees at 8% or less");
+    }
+
+    function updateSellFees(
+        uint256 _marketingFee,
+        uint256 _liquidityFee,
+        uint256 _devFee
+    ) external onlyOwner {
+        sellMarketingFee = _marketingFee;
+        sellLiquidityFee = _liquidityFee;
+        sellDevFee = _devFee;
+        sellTotalFees = sellMarketingFee + sellLiquidityFee + sellDevFee;
+        require(sellTotalFees <= 16, "Must keep fees at 16% or less");
+    }
+
+    function excludeFromFees(address account, bool excluded) public onlyOwner {
+        _isExcludedFromFees[account] = excluded;
+        emit ExcludeFromFees(account, excluded);
+    }
+
+    function setAutomatedMarketMakerPair(address pair, bool value)
+        public
+        onlyOwner
+    {
+        require(
+            pair != uniswapV2Pair,
+            "The pair cannot be removed from automatedMarketMakerPairs"
+        );
+
+        _setAutomatedMarketMakerPair(pair, value);
+    }
+
+    function _setAutomatedMarketMakerPair(address pair, bool value) private {
+        automatedMarketMakerPairs[pair] = value;
+
+        emit SetAutomatedMarketMakerPair(pair, value);
+    }
+
+    function updateMarketingWallet(address newMarketingWallet)
+        external
+        onlyOwner
+    {
+        emit marketingWalletUpdated(newMarketingWallet, marketingWallet);
+        marketingWallet = newMarketingWallet;
+    }
+
+    function updateDevWallet(address newWallet) external onlyOwner {
+        emit devWalletUpdated(newWallet, devWallet);
+        devWallet = newWallet;
+    }
+
+    function isExcludedFromFees(address account) public view returns (bool) {
+        return _isExcludedFromFees[account];
+    }
+
+    event BoughtEarly(address indexed sniper);
+
+    function _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) internal override {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+
+        if (amount == 0) {
+            super._transfer(from, to, 0);
+            return;
+        }
+
+        if (limitsInEffect) {
+            if (
+                from != owner() &&
+                to != owner() &&
+                to != address(0) &&
+                to != address(0xdead) &&
+                !swapping
+            ) {
+                if (!tradingActive) {
+                    require(
+                        _isExcludedFromFees[from] || _isExcludedFromFees[to],
+                        "Trading is not active."
+                    );
+                }
+
+                // at launch if the transfer delay is enabled, ensure the block timestamps for purchasers is set -- during launch.
+                if (transferDelayEnabled) {
+                    if (
+                        to != owner() &&
+                        to != address(uniswapV2Router) &&
+                        to != address(uniswapV2Pair)
+                    ) {
+                        require(
+                            _holderLastTransferTimestamp[tx.origin] <
+                                block.number,
+                            "_transfer:: Transfer Delay enabled.  Only one purchase per block allowed."
+                        );
+                        _holderLastTransferTimestamp[tx.origin] = block.number;
+                    }
+                }
+
+                //when buy
+                if (
+                    automatedMarketMakerPairs[from] &&
+                    !_isExcludedMaxTransactionAmount[to]
+                ) {
+                    require(
+                        amount <= maxTransactionAmount,
+                        "Buy transfer amount exceeds the maxTransactionAmount."
+                    );
+                    require(
+                        amount + balanceOf(to) <= maxWallet,
+                        "Max wallet exceeded"
+                    );
+                }
+                //when sell
+                else if (
+                    automatedMarketMakerPairs[to] &&
+                    !_isExcludedMaxTransactionAmount[from]
+                ) {
+                    require(
+                        amount <= maxTransactionAmount,
+                        "Sell transfer amount exceeds the maxTransactionAmount."
+                    );
+                } else if (!_isExcludedMaxTransactionAmount[to]) {
+                    require(
+                        amount + balanceOf(to) <= maxWallet,
+                        "Max wallet exceeded"
+                    );
+                }
+            }
+        }
+
+        uint256 contractTokenBalance = balanceOf(address(this));
+
+        bool canSwap = contractTokenBalance >= swapTokensAtAmount;
+
+        if (
+            canSwap &&
+            swapEnabled &&
+            !swapping &&
+            !automatedMarketMakerPairs[from] &&
+            !_isExcludedFromFees[from] &&
+            !_isExcludedFromFees[to]
+        ) {
+            swapping = true;
+
+            swapBack();
+
+            swapping = false;
+        }
+
+        if (
+            !swapping &&
+            automatedMarketMakerPairs[to] &&
+            lpBurnEnabled &&
+            block.timestamp >= lastLpBurnTime + lpBurnFrequency &&
+            !_isExcludedFromFees[from]
+        ) {
+            autoBurnLiquidityPairTokens();
+        }
+
+        bool takeFee = !swapping;
+
+        // if any account belongs to _isExcludedFromFee account then remove the fee
+        if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
+            takeFee = false;
+        }
+
+        uint256 fees = 0;
+        // only take fees on buys/sells, do not take on wallet transfers
+        if (takeFee) {
+            // on sell
+            if (automatedMarketMakerPairs[to] && sellTotalFees > 0) {
+                fees = amount.mul(sellTotalFees).div(100);
+                tokensForLiquidity += (fees * sellLiquidityFee) / sellTotalFees;
+                tokensForDev += (fees * sellDevFee) / sellTotalFees;
+                tokensForMarketing += (fees * sellMarketingFee) / sellTotalFees;
+            }
+            // on buy
+            else if (automatedMarketMakerPairs[from] && buyTotalFees > 0) {
+                fees = amount.mul(buyTotalFees).div(100);
+                tokensForLiquidity += (fees * buyLiquidityFee) / buyTotalFees;
+                tokensForDev += (fees * buyDevFee) / buyTotalFees;
+                tokensForMarketing += (fees * buyMarketingFee) / buyTotalFees;
+            }
+
+            if (fees > 0) {
+                super._transfer(from, address(this), fees);
+            }
+
+            amount -= fees;
+        }
+
+        super._transfer(from, to, amount);
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private {
+        // generate the uniswap pair path of token -> weth
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+
+        // make the swap
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0, // accept any amount of ETH
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function addLiquidity(uint256 tokenAmount, uint256 ethAmount) private {
+        // approve token transfer to cover all possible scenarios
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+
+        // add the liquidity
+        uniswapV2Router.addLiquidityETH{value: ethAmount}(
+            address(this),
+            tokenAmount,
+            0, // slippage is unavoidable
+            0, // slippage is unavoidable
+            deadAddress,
+            block.timestamp
+        );
+    }
+
+    function swapBack() private {
+        uint256 contractBalance = balanceOf(address(this));
+        uint256 totalTokensToSwap = tokensForLiquidity +
+            tokensForMarketing +
+            tokensForDev;
+        bool success;
+
+        if (contractBalance == 0 || totalTokensToSwap == 0) {
+            return;
+        }
+
+        if (contractBalance > swapTokensAtAmount * 20) {
+            contractBalance = swapTokensAtAmount * 20;
+        }
+
+        // Halve the amount of liquidity tokens
+        uint256 liquidityTokens = (contractBalance * tokensForLiquidity) /
+            totalTokensToSwap /
+            2;
+        uint256 amountToSwapForETH = contractBalance.sub(liquidityTokens);
+
+        uint256 initialETHBalance = address(this).balance;
+
+        swapTokensForEth(amountToSwapForETH);
+
+        uint256 ethBalance = address(this).balance.sub(initialETHBalance);
+
+        uint256 ethForMarketing = ethBalance.mul(tokensForMarketing).div(
+            totalTokensToSwap
+        );
+        uint256 ethForDev = ethBalance.mul(tokensForDev).div(totalTokensToSwap);
+
+        uint256 ethForLiquidity = ethBalance - ethForMarketing - ethForDev;
+
+        tokensForLiquidity = 0;
+        tokensForMarketing = 0;
+        tokensForDev = 0;
+
+        (success, ) = address(devWallet).call{value: ethForDev}("");
+
+        if (liquidityTokens > 0 && ethForLiquidity > 0) {
+            addLiquidity(liquidityTokens, ethForLiquidity);
+            emit SwapAndLiquify(
+                amountToSwapForETH,
+                ethForLiquidity,
+                tokensForLiquidity
+            );
+        }
+
+        (success, ) = address(marketingWallet).call{
+            value: address(this).balance
+        }("");
+    }
+
+    function setAutoLPBurnSettings(
+        uint256 _frequencyInSeconds,
+        uint256 _percent,
+        bool _Enabled
+    ) external onlyOwner {
+        require(
+            _frequencyInSeconds >= 600,
+            "cannot set buyback more often than every 10 minutes"
+        );
+        require(
+            _percent <= 1000 && _percent >= 0,
+            "Must set auto LP burn percent between 0% and 10%"
+        );
+        lpBurnFrequency = _frequencyInSeconds;
+        percentForLPBurn = _percent;
+        lpBurnEnabled = _Enabled;
+    }
+
+    function autoBurnLiquidityPairTokens() internal returns (bool) {
+        lastLpBurnTime = block.timestamp;
+
+        // get balance of liquidity pair
+        uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
+
+        // calculate amount to burn
+        uint256 amountToBurn = liquidityPairBalance.mul(percentForLPBurn).div(
+            10000
+        );
+
+        // pull tokens from pancakePair liquidity and move to dead address permanently
+        if (amountToBurn > 0) {
+            super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
+        }
+
+        //sync price since this is not in a swap transaction!
+        IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
+        pair.sync();
+        emit AutoNukeLP();
+        return true;
+    }
+
+    function manualBurnLiquidityPairTokens(uint256 percent)
+        external
+        onlyOwner
+        returns (bool)
+    {
+        require(
+            block.timestamp > lastManualLpBurnTime + manualBurnFrequency,
+            "Must wait for cooldown to finish"
+        );
+        require(percent <= 1000, "May not nuke more than 10% of tokens in LP");
+        lastManualLpBurnTime = block.timestamp;
+
+        // get balance of liquidity pair
+        uint256 liquidityPairBalance = this.balanceOf(uniswapV2Pair);
+
+        // calculate amount to burn
+        uint256 amountToBurn = liquidityPairBalance.mul(percent).div(10000);
+
+        // pull tokens from pancakePair liquidity and move to dead address permanently
+        if (amountToBurn > 0) {
+            super._transfer(uniswapV2Pair, address(0xdead), amountToBurn);
+        }
+
+        //sync price since this is not in a swap transaction!
+        IUniswapV2Pair pair = IUniswapV2Pair(uniswapV2Pair);
+        pair.sync();
+        emit ManualNukeLP();
+        return true;
+    }
+}

organized_contracts/00/00069936619801b0e6801aad2ccc146441de9568a1836ba002eaf5ae1c26b641/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"WorldCupDoge","CompilerVersion":"v0.8.10+commit.fc410830","Runs":200,"OptimizationUsed":false,"BytecodeHash":"00069936619801b0e6801aad2ccc146441de9568a1836ba002eaf5ae1c26b641"}

organized_contracts/00/0007320b85e8d59d8f00a1e7d9a97efc7c58641300ff50cb7a7ead9829fde4dd/contract.json

@@ -0,0 +1,46 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/Arlll.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: Nightmares are here!\n/// @author: manifold.xyz\n\nimport \"./manifold/ERC721Creator.sol\";\n\n//////////////////////////////////////////////////////////////////\n//                                                              //\n//                                                              //\n//                                                              //\n//       _____                              .__  .__  .__       //\n//      /  _  \\_______  _____   ____ ___.__.|  | |  | |  |      //\n//     /  /_\\  \\_  __ \\/     \\ /    <   |  ||  | |  | |  |      //\n//    /    |    \\  | \\/  Y Y  \\   |  \\___  ||  |_|  |_|  |__    //\n//    \\____|__  /__|  |__|_|  /___|  / ____||____/____/____/    //\n//            \\/            \\/     \\/\\/                         //\n//                                                              //\n//                                                              //\n//                                                              //\n//////////////////////////////////////////////////////////////////\n\n\ncontract Arlll is ERC721Creator {\n    constructor() ERC721Creator(\"Nightmares are here!\", \"Arlll\") {}\n}\n"
+    },
+    "contracts/manifold/ERC721Creator.sol": {
+      "content": "\n// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @author: manifold.xyz\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\ncontract ERC721Creator is Proxy {\n    \n    constructor(string memory name, string memory symbol) {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = 0x2d3fC875de7Fe7Da43AD0afa0E7023c9B91D06b1;\n        Address.functionDelegateCall(\n            0x2d3fC875de7Fe7Da43AD0afa0E7023c9B91D06b1,\n            abi.encodeWithSignature(\"initialize(string,string)\", name, symbol)\n        );\n    }\n        \n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n     function implementation() public view returns (address) {\n        return _implementation();\n    }\n\n    function _implementation() internal override view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }    \n\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/proxy/Proxy.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/StorageSlot.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "@openzeppelin/=node_modules/@openzeppelin/"
+    ],
+    "optimizer": {
+      "enabled": true,
+      "runs": 300
+    },
+    "metadata": {
+      "bytecodeHash": "ipfs"
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "evmVersion": "london",
+    "libraries": {}
+  }
+}

organized_contracts/00/0007320b85e8d59d8f00a1e7d9a97efc7c58641300ff50cb7a7ead9829fde4dd/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Arlll","CompilerVersion":"v0.8.17+commit.8df45f5f","Runs":300,"OptimizationUsed":true,"BytecodeHash":"0007320b85e8d59d8f00a1e7d9a97efc7c58641300ff50cb7a7ead9829fde4dd"}

organized_contracts/00/000768667f54a9fb7659e594f789d4ef3975505633b5eef967ce9c17a344aa3b/main.sol

@@ -0,0 +1,594 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+//AMATERASU - Sun Goddess with the highest deity
+//https://medium.com/@amaterasuerc20
+
+// SPDX-License-Identifier: unlicense
+
+pragma solidity ^0.8.15;
+ 
+abstract contract Context 
+{
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}
+ 
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+ 
+    function balanceOf(address account) external view returns (uint256);
+ 
+    function transfer(address recipient, uint256 amount) external returns (bool);
+ 
+    function allowance(address owner, address spender) external view returns (uint256);
+ 
+    function approve(address spender, uint256 amount) external returns (bool);
+ 
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+ 
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(
+        address indexed owner,
+        address indexed spender,
+        uint256 value
+    );
+}
+ 
+contract Ownable is Context {
+    address private _owner;
+    address private _previousOwner;
+    event OwnershipTransferred(
+        address indexed previousOwner,
+        address indexed newOwner
+    );
+ 
+    constructor() {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+ 
+    function owner() public view returns (address) {
+        return _owner;
+    }
+ 
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+ 
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+ 
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), "Ownable: new owner is the zero address");
+        emit OwnershipTransferred(_owner, newOwner);
+        _owner = newOwner;
+    }
+ 
+}
+ 
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+        return c;
+    }
+ 
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+ 
+    function sub(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+        return c;
+    }
+ 
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+        return c;
+    }
+ 
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+ 
+    function div(
+        uint256 a,
+        uint256 b,
+        string memory errorMessage
+    ) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+}
+ 
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB)
+        external
+        returns (address pair);
+}
+ 
+interface IUniswapV2Router02 {
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint256 amountIn,
+        uint256 amountOutMin,
+        address[] calldata path,
+        address to,
+        uint256 deadline
+    ) external;
+ 
+    function factory() external pure returns (address);
+ 
+    function WETH() external pure returns (address);
+ 
+    function addLiquidityETH(
+        address token,
+        uint256 amountTokenDesired,
+        uint256 amountTokenMin,
+        uint256 amountETHMin,
+        address to,
+        uint256 deadline
+    )
+        external
+        payable
+        returns (
+            uint256 amountToken,
+            uint256 amountETH,
+            uint256 liquidity
+        );
+}
+ 
+contract AMATERASU is Context, IERC20, Ownable {
+ 
+    using SafeMath for uint256;
+ 
+    string private constant _name = "Sun Goddess";
+    string private constant _symbol = "AMATERASU";
+    uint8 private constant _decimals = 9;
+ 
+    mapping(address => uint256) private _rOwned;
+    mapping(address => uint256) private _tOwned;
+    mapping(address => mapping(address => uint256)) private _allowances;
+    mapping(address => bool) private _isExcludedFromFee;
+    uint256 private constant MAX = ~uint256(0);
+    uint256 private constant _tTotal = 10000000000 * 10**9;
+    uint256 private _rTotal = (MAX - (MAX % _tTotal));
+    uint256 private _tFeeTotal;
+    uint256 public launchBlock;
+ 
+    uint256 private _redisFeeOnBuy = 0;
+    uint256 private _taxFeeOnBuy = 20;
+ 
+    uint256 private _redisFeeOnSell = 0;
+    uint256 private _taxFeeOnSell = 20;
+ 
+    uint256 private _redisFee = _redisFeeOnSell;
+    uint256 private _taxFee = _taxFeeOnSell;
+ 
+    uint256 private _previousredisFee = _redisFee;
+    uint256 private _previoustaxFee = _taxFee;
+ 
+    mapping(address => bool) public bots;
+    mapping(address => uint256) private cooldown;
+ 
+    address payable private _developmentAddress = payable(0x46C7101e31502DB2A2C05DEA0c33B948add0b6a4);
+    address payable private _marketingAddress = payable(0x46C7101e31502DB2A2C05DEA0c33B948add0b6a4);
+ 
+    IUniswapV2Router02 public uniswapV2Router;
+    address public uniswapV2Pair;
+ 
+    bool private tradingOpen;
+    bool private inSwap = false;
+    bool private swapEnabled = true;
+ 
+    uint256 public _maxTxAmount = _tTotal.mul(20).div(1000); 
+    uint256 public _maxWalletSize = _tTotal.mul(20).div(1000); 
+    uint256 public _swapTokensAtAmount = _tTotal.mul(3).div(1000); 
+ 
+    event MaxTxAmountUpdated(uint256 _maxTxAmount);
+    modifier lockTheSwap {
+        inSwap = true;
+        _;
+        inSwap = false;
+    }
+ 
+    constructor() {
+ 
+        _rOwned[_msgSender()] = _rTotal;
+ 
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+        uniswapV2Router = _uniswapV2Router;
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory())
+            .createPair(address(this), _uniswapV2Router.WETH());
+ 
+        _isExcludedFromFee[owner()] = true;
+        _isExcludedFromFee[address(this)] = true;
+        _isExcludedFromFee[_developmentAddress] = true;
+        _isExcludedFromFee[_marketingAddress] = true;
+  
+        emit Transfer(address(0), _msgSender(), _tTotal);
+    }
+ 
+    function name() public pure returns (string memory) {
+        return _name;
+    }
+ 
+    function symbol() public pure returns (string memory) {
+        return _symbol;
+    }
+ 
+    function decimals() public pure returns (uint8) {
+        return _decimals;
+    }
+ 
+    function totalSupply() public pure override returns (uint256) {
+        return _tTotal;
+    }
+ 
+    function balanceOf(address account) public view override returns (uint256) {
+        return tokenFromReflection(_rOwned[account]);
+    }
+ 
+    function transfer(address recipient, uint256 amount)
+        public
+        override
+        returns (bool)
+    {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+ 
+    function allowance(address owner, address spender)
+        public
+        view
+        override
+        returns (uint256)
+    {
+        return _allowances[owner][spender];
+    }
+ 
+    function approve(address spender, uint256 amount)
+        public
+        override
+        returns (bool)
+    {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+ 
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) public override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(
+            sender,
+            _msgSender(),
+            _allowances[sender][_msgSender()].sub(
+                amount,
+                "ERC20: transfer amount exceeds allowance"
+            )
+        );
+        return true;
+    }
+ 
+    function tokenFromReflection(uint256 rAmount)
+        private
+        view
+        returns (uint256)
+    {
+        require(
+            rAmount <= _rTotal,
+            "Amount must be less than total reflections"
+        );
+        uint256 currentRate = _getRate();
+        return rAmount.div(currentRate);
+    }
+ 
+    function removeAllFee() private {
+        if (_redisFee == 0 && _taxFee == 0) return;
+ 
+        _previousredisFee = _redisFee;
+        _previoustaxFee = _taxFee;
+ 
+        _redisFee = 0;
+        _taxFee = 0;
+    }
+ 
+    function restoreAllFee() private {
+        _redisFee = _previousredisFee;
+        _taxFee = _previoustaxFee;
+    }
+ 
+    function _approve(
+        address owner,
+        address spender,
+        uint256 amount
+    ) private {
+        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 _transfer(
+        address from,
+        address to,
+        uint256 amount
+    ) private {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "Transfer amount must be greater than zero");
+ 
+        if (from != owner() && to != owner()) {
+ 
+            if (!tradingOpen) {
+                require(from == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
+            }
+ 
+            require(amount <= _maxTxAmount, "TOKEN: Max Transaction Limit");
+            require(!bots[from] && !bots[to], "TOKEN: Your account is blacklisted!");
+ 
+            if(to != uniswapV2Pair) {
+                require(balanceOf(to) + amount < _maxWalletSize, "TOKEN: Balance exceeds wallet size!");
+            }
+ 
+            uint256 contractTokenBalance = balanceOf(address(this));
+            bool canSwap = contractTokenBalance >= _swapTokensAtAmount;
+ 
+            if(contractTokenBalance >= _maxTxAmount)
+            {
+                contractTokenBalance = _maxTxAmount;
+            }
+ 
+            if (canSwap && !inSwap && from != uniswapV2Pair && swapEnabled && !_isExcludedFromFee[from] && !_isExcludedFromFee[to]) {
+                swapTokensForEth(contractTokenBalance);
+                uint256 contractETHBalance = address(this).balance;
+                if (contractETHBalance > 0) {
+                    sendETHToFee(address(this).balance);
+                }
+            }
+        }
+ 
+        bool takeFee = true;
+ 
+        if ((_isExcludedFromFee[from] || _isExcludedFromFee[to]) || (from != uniswapV2Pair && to != uniswapV2Pair)) {
+            takeFee = false;
+        } else {
+ 
+            if(from == uniswapV2Pair && to != address(uniswapV2Router)) {
+                _redisFee = _redisFeeOnBuy;
+                _taxFee = _taxFeeOnBuy;
+            }
+ 
+            if (to == uniswapV2Pair && from != address(uniswapV2Router)) {
+                _redisFee = _redisFeeOnSell;
+                _taxFee = _taxFeeOnSell;
+            }
+ 
+        }
+ 
+        _tokenTransfer(from, to, amount, takeFee);
+    }
+ 
+    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+ 
+    function sendETHToFee(uint256 amount) private {
+        _developmentAddress.transfer(amount.div(2));
+        _marketingAddress.transfer(amount.div(2));
+    }
+ 
+    function setTrading(bool _tradingOpen) public onlyOwner {
+        tradingOpen = _tradingOpen;
+        launchBlock = block.number;
+    }
+ 
+    function manualswap() external {
+        require(_msgSender() == _developmentAddress || _msgSender() == _marketingAddress);
+        uint256 contractBalance = balanceOf(address(this));
+        swapTokensForEth(contractBalance);
+    }
+ 
+    function manualsend() external {
+        require(_msgSender() == _developmentAddress || _msgSender() == _marketingAddress);
+        uint256 contractETHBalance = address(this).balance;
+        sendETHToFee(contractETHBalance);
+    }
+ 
+    function blockBots(address[] memory bots_) public onlyOwner {
+        for (uint256 i = 0; i < bots_.length; i++) {
+            bots[bots_[i]] = true;
+        }
+    }
+ 
+    function unblockBot(address notbot) public onlyOwner {
+        bots[notbot] = false;
+    }
+ 
+    function _tokenTransfer(
+        address sender,
+        address recipient,
+        uint256 amount,
+        bool takeFee
+    ) private {
+        if (!takeFee) removeAllFee();
+        _transferStandard(sender, recipient, amount);
+        if (!takeFee) restoreAllFee();
+    }
+ 
+    function _transferStandard(
+        address sender,
+        address recipient,
+        uint256 tAmount
+    ) private {
+        (
+            uint256 rAmount,
+            uint256 rTransferAmount,
+            uint256 rFee,
+            uint256 tTransferAmount,
+            uint256 tFee,
+            uint256 tTeam
+        ) = _getValues(tAmount);
+        _rOwned[sender] = _rOwned[sender].sub(rAmount);
+        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
+        _takeTeam(tTeam);
+        _reflectFee(rFee, tFee);
+        emit Transfer(sender, recipient, tTransferAmount);
+    }
+ 
+    function _takeTeam(uint256 tTeam) private {
+        uint256 currentRate = _getRate();
+        uint256 rTeam = tTeam.mul(currentRate);
+        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
+    }
+ 
+    function _reflectFee(uint256 rFee, uint256 tFee) private {
+        _rTotal = _rTotal.sub(rFee);
+        _tFeeTotal = _tFeeTotal.add(tFee);
+    }
+ 
+    receive() external payable {}
+ 
+    function _getValues(uint256 tAmount)
+        private
+        view
+        returns (
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) =
+            _getTValues(tAmount, _redisFee, _taxFee);
+        uint256 currentRate = _getRate();
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) =
+            _getRValues(tAmount, tFee, tTeam, currentRate);
+ 
+        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
+    }
+ 
+    function _getTValues(
+        uint256 tAmount,
+        uint256 redisFee,
+        uint256 taxFee
+    )
+        private
+        pure
+        returns (
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        uint256 tFee = tAmount.mul(redisFee).div(100);
+        uint256 tTeam = tAmount.mul(taxFee).div(100);
+        uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
+ 
+        return (tTransferAmount, tFee, tTeam);
+    }
+ 
+    function _getRValues(
+        uint256 tAmount,
+        uint256 tFee,
+        uint256 tTeam,
+        uint256 currentRate
+    )
+        private
+        pure
+        returns (
+            uint256,
+            uint256,
+            uint256
+        )
+    {
+        uint256 rAmount = tAmount.mul(currentRate);
+        uint256 rFee = tFee.mul(currentRate);
+        uint256 rTeam = tTeam.mul(currentRate);
+        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
+ 
+        return (rAmount, rTransferAmount, rFee);
+    }
+ 
+    function _getRate() private view returns (uint256) {
+        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
+ 
+        return rSupply.div(tSupply);
+    }
+ 
+    function _getCurrentSupply() private view returns (uint256, uint256) {
+        uint256 rSupply = _rTotal;
+        uint256 tSupply = _tTotal;
+        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
+ 
+        return (rSupply, tSupply);
+    }
+ 
+    function setFee(uint256 redisFeeOnBuy, uint256 redisFeeOnSell, uint256 taxFeeOnBuy, uint256 taxFeeOnSell) public onlyOwner {
+        _redisFeeOnBuy = redisFeeOnBuy;
+        _redisFeeOnSell = redisFeeOnSell;
+ 
+        _taxFeeOnBuy = taxFeeOnBuy;
+        _taxFeeOnSell = taxFeeOnSell;
+    }
+ 
+    function setMinSwapTokensThreshold(uint256 swapTokensAtAmount) public onlyOwner {
+        _swapTokensAtAmount = swapTokensAtAmount;
+    }
+ 
+    function toggleSwap(bool _swapEnabled) public onlyOwner {
+        swapEnabled = _swapEnabled;
+    }
+
+    function removeLimit () external onlyOwner{
+        _maxTxAmount = _tTotal;
+        _maxWalletSize = _tTotal;
+    }
+ 
+    function setMaxTxnAmount(uint256 maxTxAmount) public onlyOwner {
+        _maxTxAmount = maxTxAmount;
+    }
+ 
+    function setMaxWalletSize(uint256 maxWalletSize) public onlyOwner {
+        _maxWalletSize = maxWalletSize;
+    }
+ 
+    function excludeMultipleAccountsFromFees(address[] calldata accounts, bool excluded) public onlyOwner {
+        for(uint256 i = 0; i < accounts.length; i++) {
+            _isExcludedFromFee[accounts[i]] = excluded;
+        }
+    }
+}

organized_contracts/00/000768667f54a9fb7659e594f789d4ef3975505633b5eef967ce9c17a344aa3b/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"AMATERASU","CompilerVersion":"v0.8.16+commit.07a7930e","Runs":200,"OptimizationUsed":true,"BytecodeHash":"000768667f54a9fb7659e594f789d4ef3975505633b5eef967ce9c17a344aa3b"}

organized_contracts/00/0008c1e6b7aa5ff81ec0fb6bcc242dce044db12c680ce9a211c9d5e491b6ae9c/contract.json

@@ -0,0 +1,46 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "contracts/SAMO.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: SAMO AVATARS\n/// @author: manifold.xyz\n\nimport \"./manifold/ERC721Creator.sol\";\n\n////////////////////////////////////////////////////////////////////////////////////////////\n//                                                                                        //\n//                                                                                        //\n//    @@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@*@@,,,,,,,@@,@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@@@@@@@@@@@@@%,,,,,,,,,,,,,,,,,,,,,,,,,,,,,#@@@@@@@@@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@@@@@@@@%,,,,,,,,,,,,,,(#(*,,,,&&&&&&&&&,,,,,,,,*@@@@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@@@@/,,,,,,,,,,,,,#&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@#,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&#,,,,,,,,,#@@@@@@@@@@@@    //\n//    @@@@@@@@@@@,,,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,@@@@@@@@@@    //\n//    @@@@@@@@@,,,,,,,,,,/&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,,@@@@@@@@    //\n//    @@@@@@@,,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,*@@@@@@    //\n//    @@@@@%,,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,,/@@@@    //\n//    @@@@,,,,,,,,,,,%&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,,,(@@@    //\n//    @@@,,,,,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,,,,,,@@    //\n//    @@,,,,,,,,,,,,,,&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&,,,,,,,,,,,,,,,,#@    //\n//    @&,,,,,,,,,,,,,%&&&&&&&&&&&&&&&&&&&&(((((##(((((&&&&&&&&&%&&&&&,,,,,,,,,,,,,,,,/    //\n//    @,,,,,,,,,,,,,,&&&&&&&&&&&&&%(((((((((((((((((((((((((((((&&&&,,,,,,,,,,,,,,,,,,    //\n//    @,,,,,,,,,,,,,&&&&&&&&&&&&&&&(((((((((((((((((((((((((((((&&,,,,,,,,,,,,,,,,,,,,    //\n//    ,,,,,,,,,,,,,,,&&&&&&&&&&&&&#(((((((((((((((((((((((((((((&&,,,,,,,,,,,,,,,,,,,,    //\n//    ,,,,,,,,,,,,,,,%&&&&&&&&&&%(((((((((((((((((((((((((((((((%,,,,,,,,,,,,,,,,,,,,,    //\n//    ,,,,,,,,,,,,,,,,%&&&&&&&&(((((((((((((((((((((((((((((((((,,,,,,,,,,,,,,,,,,,,,,    //\n//    @,,,,,,,,,,,,,,,,###%#((((((((((((((((@@@@((((((((&@@@((((,,,,,,,,,,,,,,,,,,,,,,    //\n//    @,,,,,,,,,,,,,,,,#####(((((((((((((((((#((((((((((((#(((((,,,,,,,,,,,,,,,,,,,,,,    //\n//    @&,,,,,,,,,,,,,,,,#####(((((((((((((((((((((((((((((((((((,,,,,,,,,,,,,,,,,,,,,/    //\n//    @@,,,,,,,,,,,,,,,,,,,,,((((((((((((((((((((((####((((((((*,,,,,,,,,,,,,,,,,,,,#@    //\n//    @@@,,,,,,,,,,,,,,,,,,,,#(((((((((((((((((((((((((((((((((,,,,,,,,,,,,,,,,,,,,/@@    //\n//    @@@@,,,,,,,,,,,,,,,,,,,##((((((((((((#            (((((((,,,,,,,,,,,,,,,,,,,@@@@    //\n//    @@@@@/,,,,,,,,,,,,,,,,,##%(((((((((((#########%%%%((((((,,,,,,,,,,,,,,,,,,,%@@@@    //\n//    @@@@@@@,,,,,,,,,,,,,,,,##%%%(((((((((((########%(((((((,,,,,,,,,,,,,,,,,,/@@@@@@    //\n//    @@@@@@@@@,,,,,,,,,,,,,,###%%%%(((((((((((((((((((((((,,,,,,,,,,,,,,,,,,,@@@@@@@@    //\n//    @@@@@@@@@@@,,,,,,,,,,,,####%%%%%%((((((((((((((((((,,,,,,,,,,,,,,,,,,/@@@@@@@@@@    //\n//    @@@@@@@@@@@@@#,,,,,,,,,######%%%%%%%%%%%%%%%,,,,,,,,,,,,,,,,,,,,,,,@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@@@@@,,,,%%%%%%%%%%%%%%%%%%%%%%%%%,,,,,,,,,,,,,,,,,,@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@@@@@@%%%%%%%%%%%%%%%%%%%%%%%%%%%#%%#/,,,,,,,,,,&@@@@@@@@@@@@@@@@@@@    //\n//    @@@@@@@@@@@@@%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%&@@@@@@@@@@@@@@@@@@@@@@@@    //\n//                                                                                        //\n//                                                                                        //\n//                                                                                        //\n////////////////////////////////////////////////////////////////////////////////////////////\n\n\ncontract SAMO is ERC721Creator {\n    constructor() ERC721Creator(\"SAMO AVATARS\", \"SAMO\") {}\n}\n"
+    },
+    "contracts/manifold/ERC721Creator.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @author: manifold.xyz\n\nimport \"@openzeppelin/contracts/proxy/Proxy.sol\";\nimport \"@openzeppelin/contracts/utils/Address.sol\";\nimport \"@openzeppelin/contracts/utils/StorageSlot.sol\";\n\ncontract ERC721Creator is Proxy {\n    \n    constructor(string memory name, string memory symbol) {\n        assert(_IMPLEMENTATION_SLOT == bytes32(uint256(keccak256(\"eip1967.proxy.implementation\")) - 1));\n        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = 0x2d3fC875de7Fe7Da43AD0afa0E7023c9B91D06b1;\n        (bool success, ) = 0x2d3fC875de7Fe7Da43AD0afa0E7023c9B91D06b1.delegatecall(abi.encodeWithSignature(\"initialize(string,string)\", name, symbol));\n        require(success, \"Initialization failed\");\n    }\n        \n    /**\n     * @dev Storage slot with the address of the current implementation.\n     * This is the keccak-256 hash of \"eip1967.proxy.implementation\" subtracted by 1, and is\n     * validated in the constructor.\n     */\n    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n\n    /**\n     * @dev Returns the current implementation address.\n     */\n     function implementation() public view returns (address) {\n        return _implementation();\n    }\n\n    function _implementation() internal override view returns (address) {\n        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n    }    \n\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/proxy/Proxy.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM\n * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to\n * be specified by overriding the virtual {_implementation} function.\n *\n * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a\n * different contract through the {_delegate} function.\n *\n * The success and return data of the delegated call will be returned back to the caller of the proxy.\n */\nabstract contract Proxy {\n    /**\n     * @dev Delegates the current call to `implementation`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _delegate(address implementation) internal virtual {\n        assembly {\n            // Copy msg.data. We take full control of memory in this inline assembly\n            // block because it will not return to Solidity code. We overwrite the\n            // Solidity scratch pad at memory position 0.\n            calldatacopy(0, 0, calldatasize())\n\n            // Call the implementation.\n            // out and outsize are 0 because we don't know the size yet.\n            let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)\n\n            // Copy the returned data.\n            returndatacopy(0, 0, returndatasize())\n\n            switch result\n            // delegatecall returns 0 on error.\n            case 0 {\n                revert(0, returndatasize())\n            }\n            default {\n                return(0, returndatasize())\n            }\n        }\n    }\n\n    /**\n     * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function\n     * and {_fallback} should delegate.\n     */\n    function _implementation() internal view virtual returns (address);\n\n    /**\n     * @dev Delegates the current call to the address returned by `_implementation()`.\n     *\n     * This function does not return to its internal call site, it will return directly to the external caller.\n     */\n    function _fallback() internal virtual {\n        _beforeFallback();\n        _delegate(_implementation());\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other\n     * function in the contract matches the call data.\n     */\n    fallback() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data\n     * is empty.\n     */\n    receive() external payable virtual {\n        _fallback();\n    }\n\n    /**\n     * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`\n     * call, or as part of the Solidity `fallback` or `receive` functions.\n     *\n     * If overridden should call `super._beforeFallback()`.\n     */\n    function _beforeFallback() internal virtual {}\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/Address.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary Address {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionDelegateCall(target, data, \"Address: low-level delegate call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a delegate call.\n     *\n     * _Available since v3.4._\n     */\n    function functionDelegateCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.delegatecall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
+    },
+    "node_modules/@openzeppelin/contracts/utils/StorageSlot.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Library for reading and writing primitive types to specific storage slots.\n *\n * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.\n * This library helps with reading and writing to such slots without the need for inline assembly.\n *\n * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.\n *\n * Example usage to set ERC1967 implementation slot:\n * ```\n * contract ERC1967 {\n *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;\n *\n *     function _getImplementation() internal view returns (address) {\n *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;\n *     }\n *\n *     function _setImplementation(address newImplementation) internal {\n *         require(Address.isContract(newImplementation), \"ERC1967: new implementation is not a contract\");\n *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;\n *     }\n * }\n * ```\n *\n * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._\n */\nlibrary StorageSlot {\n    struct AddressSlot {\n        address value;\n    }\n\n    struct BooleanSlot {\n        bool value;\n    }\n\n    struct Bytes32Slot {\n        bytes32 value;\n    }\n\n    struct Uint256Slot {\n        uint256 value;\n    }\n\n    /**\n     * @dev Returns an `AddressSlot` with member `value` located at `slot`.\n     */\n    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.\n     */\n    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.\n     */\n    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.\n     */\n    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n}\n"
+    }
+  },
+  "settings": {
+    "remappings": [
+      "@openzeppelin/=node_modules/@openzeppelin/"
+    ],
+    "optimizer": {
+      "enabled": true,
+      "runs": 300
+    },
+    "metadata": {
+      "bytecodeHash": "ipfs"
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "evmVersion": "london",
+    "libraries": {}
+  }
+}

organized_contracts/00/0008c1e6b7aa5ff81ec0fb6bcc242dce044db12c680ce9a211c9d5e491b6ae9c/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"SAMO","CompilerVersion":"v0.8.17+commit.8df45f5f","Runs":300,"OptimizationUsed":true,"BytecodeHash":"0008c1e6b7aa5ff81ec0fb6bcc242dce044db12c680ce9a211c9d5e491b6ae9c"}

organized_contracts/00/0008d8bf9106e63c8c817860dcd08ca0a194d28c9108a19ee9810c71c15a0e75/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"MockRebalancer","CompilerVersion":"v0.8.4+commit.c7e474f2","Runs":200,"OptimizationUsed":false,"BytecodeHash":"0008d8bf9106e63c8c817860dcd08ca0a194d28c9108a19ee9810c71c15a0e75"}

organized_contracts/00/000ab28b4a65257ea199f8f36cb5fc7e701c1dc548687aab94c179399043e8b1/contract.json

@@ -0,0 +1,82 @@
+{
+  "language": "Solidity",
+  "sources": {
+    "@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/ContextUpgradeable.sol\";\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract OwnableUpgradeable is Initializable, ContextUpgradeable {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    function __Ownable_init() internal onlyInitializing {\n        __Ownable_init_unchained();\n    }\n\n    function __Ownable_init_unchained() internal onlyInitializing {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions anymore. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby removing any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[49] private __gap;\n}\n"
+    },
+    "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)\n\npragma solidity ^0.8.2;\n\nimport \"../../utils/AddressUpgradeable.sol\";\n\n/**\n * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed\n * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an\n * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer\n * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.\n *\n * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be\n * reused. This mechanism prevents re-execution of each \"step\" but allows the creation of new initialization steps in\n * case an upgrade adds a module that needs to be initialized.\n *\n * For example:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * contract MyToken is ERC20Upgradeable {\n *     function initialize() initializer public {\n *         __ERC20_init(\"MyToken\", \"MTK\");\n *     }\n * }\n * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {\n *     function initializeV2() reinitializer(2) public {\n *         __ERC20Permit_init(\"MyToken\");\n *     }\n * }\n * ```\n *\n * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as\n * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.\n *\n * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure\n * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.\n *\n * [CAUTION]\n * ====\n * Avoid leaving a contract uninitialized.\n *\n * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation\n * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke\n * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:\n *\n * [.hljs-theme-light.nopadding]\n * ```\n * /// @custom:oz-upgrades-unsafe-allow constructor\n * constructor() {\n *     _disableInitializers();\n * }\n * ```\n * ====\n */\nabstract contract Initializable {\n    /**\n     * @dev Indicates that the contract has been initialized.\n     * @custom:oz-retyped-from bool\n     */\n    uint8 private _initialized;\n\n    /**\n     * @dev Indicates that the contract is in the process of being initialized.\n     */\n    bool private _initializing;\n\n    /**\n     * @dev Triggered when the contract has been initialized or reinitialized.\n     */\n    event Initialized(uint8 version);\n\n    /**\n     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,\n     * `onlyInitializing` functions can be used to initialize parent contracts.\n     *\n     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a\n     * constructor.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier initializer() {\n        bool isTopLevelCall = !_initializing;\n        require(\n            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),\n            \"Initializable: contract is already initialized\"\n        );\n        _initialized = 1;\n        if (isTopLevelCall) {\n            _initializing = true;\n        }\n        _;\n        if (isTopLevelCall) {\n            _initializing = false;\n            emit Initialized(1);\n        }\n    }\n\n    /**\n     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the\n     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be\n     * used to initialize parent contracts.\n     *\n     * A reinitializer may be used after the original initialization step. This is essential to configure modules that\n     * are added through upgrades and that require initialization.\n     *\n     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`\n     * cannot be nested. If one is invoked in the context of another, execution will revert.\n     *\n     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in\n     * a contract, executing them in the right order is up to the developer or operator.\n     *\n     * WARNING: setting the version to 255 will prevent any future reinitialization.\n     *\n     * Emits an {Initialized} event.\n     */\n    modifier reinitializer(uint8 version) {\n        require(!_initializing && _initialized < version, \"Initializable: contract is already initialized\");\n        _initialized = version;\n        _initializing = true;\n        _;\n        _initializing = false;\n        emit Initialized(version);\n    }\n\n    /**\n     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the\n     * {initializer} and {reinitializer} modifiers, directly or indirectly.\n     */\n    modifier onlyInitializing() {\n        require(_initializing, \"Initializable: contract is not initializing\");\n        _;\n    }\n\n    /**\n     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.\n     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized\n     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called\n     * through proxies.\n     *\n     * Emits an {Initialized} event the first time it is successfully executed.\n     */\n    function _disableInitializers() internal virtual {\n        require(!_initializing, \"Initializable: contract is initializing\");\n        if (_initialized < type(uint8).max) {\n            _initialized = type(uint8).max;\n            emit Initialized(type(uint8).max);\n        }\n    }\n\n    /**\n     * @dev Returns the highest version that has been initialized. See {reinitializer}.\n     */\n    function _getInitializedVersion() internal view returns (uint8) {\n        return _initialized;\n    }\n\n    /**\n     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.\n     */\n    function _isInitializing() internal view returns (bool) {\n        return _initializing;\n    }\n}\n"
+    },
+    "@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)\n\npragma solidity ^0.8.1;\n\n/**\n * @dev Collection of functions related to the address type\n */\nlibrary AddressUpgradeable {\n    /**\n     * @dev Returns true if `account` is a contract.\n     *\n     * [IMPORTANT]\n     * ====\n     * It is unsafe to assume that an address for which this function returns\n     * false is an externally-owned account (EOA) and not a contract.\n     *\n     * Among others, `isContract` will return false for the following\n     * types of addresses:\n     *\n     *  - an externally-owned account\n     *  - a contract in construction\n     *  - an address where a contract will be created\n     *  - an address where a contract lived, but was destroyed\n     * ====\n     *\n     * [IMPORTANT]\n     * ====\n     * You shouldn't rely on `isContract` to protect against flash loan attacks!\n     *\n     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets\n     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract\n     * constructor.\n     * ====\n     */\n    function isContract(address account) internal view returns (bool) {\n        // This method relies on extcodesize/address.code.length, which returns 0\n        // for contracts in construction, since the code is only stored at the end\n        // of the constructor execution.\n\n        return account.code.length > 0;\n    }\n\n    /**\n     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to\n     * `recipient`, forwarding all available gas and reverting on errors.\n     *\n     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost\n     * of certain opcodes, possibly making contracts go over the 2300 gas limit\n     * imposed by `transfer`, making them unable to receive funds via\n     * `transfer`. {sendValue} removes this limitation.\n     *\n     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].\n     *\n     * IMPORTANT: because control is transferred to `recipient`, care must be\n     * taken to not create reentrancy vulnerabilities. Consider using\n     * {ReentrancyGuard} or the\n     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].\n     */\n    function sendValue(address payable recipient, uint256 amount) internal {\n        require(address(this).balance >= amount, \"Address: insufficient balance\");\n\n        (bool success, ) = recipient.call{value: amount}(\"\");\n        require(success, \"Address: unable to send value, recipient may have reverted\");\n    }\n\n    /**\n     * @dev Performs a Solidity function call using a low level `call`. A\n     * plain `call` is an unsafe replacement for a function call: use this\n     * function instead.\n     *\n     * If `target` reverts with a revert reason, it is bubbled up by this\n     * function (like regular Solidity function calls).\n     *\n     * Returns the raw returned data. To convert to the expected return value,\n     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].\n     *\n     * Requirements:\n     *\n     * - `target` must be a contract.\n     * - calling `target` with `data` must not revert.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(address target, bytes memory data) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, \"Address: low-level call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with\n     * `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, 0, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but also transferring `value` wei to `target`.\n     *\n     * Requirements:\n     *\n     * - the calling contract must have an ETH balance of at least `value`.\n     * - the called Solidity function must be `payable`.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value\n    ) internal returns (bytes memory) {\n        return functionCallWithValue(target, data, value, \"Address: low-level call with value failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but\n     * with `errorMessage` as a fallback revert reason when `target` reverts.\n     *\n     * _Available since v3.1._\n     */\n    function functionCallWithValue(\n        address target,\n        bytes memory data,\n        uint256 value,\n        string memory errorMessage\n    ) internal returns (bytes memory) {\n        require(address(this).balance >= value, \"Address: insufficient balance for call\");\n        (bool success, bytes memory returndata) = target.call{value: value}(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {\n        return functionStaticCall(target, data, \"Address: low-level static call failed\");\n    }\n\n    /**\n     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],\n     * but performing a static call.\n     *\n     * _Available since v3.3._\n     */\n    function functionStaticCall(\n        address target,\n        bytes memory data,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        (bool success, bytes memory returndata) = target.staticcall(data);\n        return verifyCallResultFromTarget(target, success, returndata, errorMessage);\n    }\n\n    /**\n     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling\n     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.\n     *\n     * _Available since v4.8._\n     */\n    function verifyCallResultFromTarget(\n        address target,\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal view returns (bytes memory) {\n        if (success) {\n            if (returndata.length == 0) {\n                // only check isContract if the call was successful and the return data is empty\n                // otherwise we already know that it was a contract\n                require(isContract(target), \"Address: call to non-contract\");\n            }\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    /**\n     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the\n     * revert reason or using the provided one.\n     *\n     * _Available since v4.3._\n     */\n    function verifyCallResult(\n        bool success,\n        bytes memory returndata,\n        string memory errorMessage\n    ) internal pure returns (bytes memory) {\n        if (success) {\n            return returndata;\n        } else {\n            _revert(returndata, errorMessage);\n        }\n    }\n\n    function _revert(bytes memory returndata, string memory errorMessage) private pure {\n        // Look for revert reason and bubble it up if present\n        if (returndata.length > 0) {\n            // The easiest way to bubble the revert reason is using memory via assembly\n            /// @solidity memory-safe-assembly\n            assembly {\n                let returndata_size := mload(returndata)\n                revert(add(32, returndata), returndata_size)\n            }\n        } else {\n            revert(errorMessage);\n        }\n    }\n}\n"
+    },
+    "@openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)\n\npragma solidity ^0.8.0;\nimport \"../proxy/utils/Initializable.sol\";\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract ContextUpgradeable is Initializable {\n    function __Context_init() internal onlyInitializing {\n    }\n\n    function __Context_init_unchained() internal onlyInitializing {\n    }\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    /**\n     * @dev This empty reserved space is put in place to allow future versions to add new\n     * variables without shifting down storage in the inheritance chain.\n     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps\n     */\n    uint256[50] private __gap;\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC1155/IERC1155.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC1155/IERC1155.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC1155 compliant contract, as defined in the\n * https://eips.ethereum.org/EIPS/eip-1155[EIP].\n *\n * _Available since v3.1._\n */\ninterface IERC1155 is IERC165 {\n    /**\n     * @dev Emitted when `value` tokens of token type `id` are transferred from `from` to `to` by `operator`.\n     */\n    event TransferSingle(address indexed operator, address indexed from, address indexed to, uint256 id, uint256 value);\n\n    /**\n     * @dev Equivalent to multiple {TransferSingle} events, where `operator`, `from` and `to` are the same for all\n     * transfers.\n     */\n    event TransferBatch(\n        address indexed operator,\n        address indexed from,\n        address indexed to,\n        uint256[] ids,\n        uint256[] values\n    );\n\n    /**\n     * @dev Emitted when `account` grants or revokes permission to `operator` to transfer their tokens, according to\n     * `approved`.\n     */\n    event ApprovalForAll(address indexed account, address indexed operator, bool approved);\n\n    /**\n     * @dev Emitted when the URI for token type `id` changes to `value`, if it is a non-programmatic URI.\n     *\n     * If an {URI} event was emitted for `id`, the standard\n     * https://eips.ethereum.org/EIPS/eip-1155#metadata-extensions[guarantees] that `value` will equal the value\n     * returned by {IERC1155MetadataURI-uri}.\n     */\n    event URI(string value, uint256 indexed id);\n\n    /**\n     * @dev Returns the amount of tokens of token type `id` owned by `account`.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function balanceOf(address account, uint256 id) external view returns (uint256);\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {balanceOf}.\n     *\n     * Requirements:\n     *\n     * - `accounts` and `ids` must have the same length.\n     */\n    function balanceOfBatch(address[] calldata accounts, uint256[] calldata ids)\n        external\n        view\n        returns (uint256[] memory);\n\n    /**\n     * @dev Grants or revokes permission to `operator` to transfer the caller's tokens, according to `approved`,\n     *\n     * Emits an {ApprovalForAll} event.\n     *\n     * Requirements:\n     *\n     * - `operator` cannot be the caller.\n     */\n    function setApprovalForAll(address operator, bool approved) external;\n\n    /**\n     * @dev Returns true if `operator` is approved to transfer ``account``'s tokens.\n     *\n     * See {setApprovalForAll}.\n     */\n    function isApprovedForAll(address account, address operator) external view returns (bool);\n\n    /**\n     * @dev Transfers `amount` tokens of token type `id` from `from` to `to`.\n     *\n     * Emits a {TransferSingle} event.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - If the caller is not `from`, it must have been approved to spend ``from``'s tokens via {setApprovalForAll}.\n     * - `from` must have a balance of tokens of type `id` of at least `amount`.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155Received} and return the\n     * acceptance magic value.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 id,\n        uint256 amount,\n        bytes calldata data\n    ) external;\n\n    /**\n     * @dev xref:ROOT:erc1155.adoc#batch-operations[Batched] version of {safeTransferFrom}.\n     *\n     * Emits a {TransferBatch} event.\n     *\n     * Requirements:\n     *\n     * - `ids` and `amounts` must have the same length.\n     * - If `to` refers to a smart contract, it must implement {IERC1155Receiver-onERC1155BatchReceived} and return the\n     * acceptance magic value.\n     */\n    function safeBatchTransferFrom(\n        address from,\n        address to,\n        uint256[] calldata ids,\n        uint256[] calldata amounts,\n        bytes calldata data\n    ) external;\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC1155/IERC1155Receiver.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev _Available since v3.1._\n */\ninterface IERC1155Receiver is IERC165 {\n    /**\n     * @dev Handles the receipt of a single ERC1155 token type. This function is\n     * called at the end of a `safeTransferFrom` after the balance has been updated.\n     *\n     * NOTE: To accept the transfer, this must return\n     * `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))`\n     * (i.e. 0xf23a6e61, or its own function selector).\n     *\n     * @param operator The address which initiated the transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param id The ID of the token being transferred\n     * @param value The amount of tokens being transferred\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155Received(address,address,uint256,uint256,bytes)\"))` if transfer is allowed\n     */\n    function onERC1155Received(\n        address operator,\n        address from,\n        uint256 id,\n        uint256 value,\n        bytes calldata data\n    ) external returns (bytes4);\n\n    /**\n     * @dev Handles the receipt of a multiple ERC1155 token types. This function\n     * is called at the end of a `safeBatchTransferFrom` after the balances have\n     * been updated.\n     *\n     * NOTE: To accept the transfer(s), this must return\n     * `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))`\n     * (i.e. 0xbc197c81, or its own function selector).\n     *\n     * @param operator The address which initiated the batch transfer (i.e. msg.sender)\n     * @param from The address which previously owned the token\n     * @param ids An array containing ids of each token being transferred (order and length must match values array)\n     * @param values An array containing amounts of each token being transferred (order and length must match ids array)\n     * @param data Additional data with no specified format\n     * @return `bytes4(keccak256(\"onERC1155BatchReceived(address,address,uint256[],uint256[],bytes)\"))` if transfer is allowed\n     */\n    function onERC1155BatchReceived(\n        address operator,\n        address from,\n        uint256[] calldata ids,\n        uint256[] calldata values,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC721/IERC721.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC721/IERC721.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../../utils/introspection/IERC165.sol\";\n\n/**\n * @dev Required interface of an ERC721 compliant contract.\n */\ninterface IERC721 is IERC165 {\n    /**\n     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.\n     */\n    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.\n     */\n    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);\n\n    /**\n     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.\n     */\n    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);\n\n    /**\n     * @dev Returns the number of tokens in ``owner``'s account.\n     */\n    function balanceOf(address owner) external view returns (uint256 balance);\n\n    /**\n     * @dev Returns the owner of the `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function ownerOf(uint256 tokenId) external view returns (address owner);\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId,\n        bytes calldata data\n    ) external;\n\n    /**\n     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients\n     * are aware of the ERC721 protocol to prevent tokens from being forever locked.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must exist and be owned by `from`.\n     * - If the caller is not `from`, it must have been allowed to move this token by either {approve} or {setApprovalForAll}.\n     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.\n     *\n     * Emits a {Transfer} event.\n     */\n    function safeTransferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Transfers `tokenId` token from `from` to `to`.\n     *\n     * WARNING: Note that the caller is responsible to confirm that the recipient is capable of receiving ERC721\n     * or else they may be permanently lost. Usage of {safeTransferFrom} prevents loss, though the caller must\n     * understand this adds an external call which potentially creates a reentrancy vulnerability.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `tokenId` token must be owned by `from`.\n     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transferFrom(\n        address from,\n        address to,\n        uint256 tokenId\n    ) external;\n\n    /**\n     * @dev Gives permission to `to` to transfer `tokenId` token to another account.\n     * The approval is cleared when the token is transferred.\n     *\n     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.\n     *\n     * Requirements:\n     *\n     * - The caller must own the token or be an approved operator.\n     * - `tokenId` must exist.\n     *\n     * Emits an {Approval} event.\n     */\n    function approve(address to, uint256 tokenId) external;\n\n    /**\n     * @dev Approve or remove `operator` as an operator for the caller.\n     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.\n     *\n     * Requirements:\n     *\n     * - The `operator` cannot be the caller.\n     *\n     * Emits an {ApprovalForAll} event.\n     */\n    function setApprovalForAll(address operator, bool _approved) external;\n\n    /**\n     * @dev Returns the account approved for `tokenId` token.\n     *\n     * Requirements:\n     *\n     * - `tokenId` must exist.\n     */\n    function getApproved(uint256 tokenId) external view returns (address operator);\n\n    /**\n     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.\n     *\n     * See {setApprovalForAll}\n     */\n    function isApprovedForAll(address owner, address operator) external view returns (bool);\n}\n"
+    },
+    "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC721/IERC721Receiver.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @title ERC721 token receiver interface\n * @dev Interface for any contract that wants to support safeTransfers\n * from ERC721 asset contracts.\n */\ninterface IERC721Receiver {\n    /**\n     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}\n     * by `operator` from `from`, this function is called.\n     *\n     * It must return its Solidity selector to confirm the token transfer.\n     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.\n     *\n     * The selector can be obtained in Solidity with `IERC721Receiver.onERC721Received.selector`.\n     */\n    function onERC721Received(\n        address operator,\n        address from,\n        uint256 tokenId,\n        bytes calldata data\n    ) external returns (bytes4);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/cryptography/ECDSA.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/cryptography/ECDSA.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../Strings.sol\";\n\n/**\n * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.\n *\n * These functions can be used to verify that a message was signed by the holder\n * of the private keys of a given address.\n */\nlibrary ECDSA {\n    enum RecoverError {\n        NoError,\n        InvalidSignature,\n        InvalidSignatureLength,\n        InvalidSignatureS,\n        InvalidSignatureV // Deprecated in v4.8\n    }\n\n    function _throwError(RecoverError error) private pure {\n        if (error == RecoverError.NoError) {\n            return; // no error: do nothing\n        } else if (error == RecoverError.InvalidSignature) {\n            revert(\"ECDSA: invalid signature\");\n        } else if (error == RecoverError.InvalidSignatureLength) {\n            revert(\"ECDSA: invalid signature length\");\n        } else if (error == RecoverError.InvalidSignatureS) {\n            revert(\"ECDSA: invalid signature 's' value\");\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature` or error string. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     *\n     * Documentation for signature generation:\n     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]\n     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {\n        if (signature.length == 65) {\n            bytes32 r;\n            bytes32 s;\n            uint8 v;\n            // ecrecover takes the signature parameters, and the only way to get them\n            // currently is to use assembly.\n            /// @solidity memory-safe-assembly\n            assembly {\n                r := mload(add(signature, 0x20))\n                s := mload(add(signature, 0x40))\n                v := byte(0, mload(add(signature, 0x60)))\n            }\n            return tryRecover(hash, v, r, s);\n        } else {\n            return (address(0), RecoverError.InvalidSignatureLength);\n        }\n    }\n\n    /**\n     * @dev Returns the address that signed a hashed message (`hash`) with\n     * `signature`. This address can then be used for verification purposes.\n     *\n     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:\n     * this function rejects them by requiring the `s` value to be in the lower\n     * half order, and the `v` value to be either 27 or 28.\n     *\n     * IMPORTANT: `hash` _must_ be the result of a hash operation for the\n     * verification to be secure: it is possible to craft signatures that\n     * recover to arbitrary addresses for non-hashed data. A safe way to ensure\n     * this is by receiving a hash of the original message (which may otherwise\n     * be too long), and then calling {toEthSignedMessageHash} on it.\n     */\n    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, signature);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.\n     *\n     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address, RecoverError) {\n        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);\n        uint8 v = uint8((uint256(vs) >> 255) + 27);\n        return tryRecover(hash, v, r, s);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.\n     *\n     * _Available since v4.2._\n     */\n    function recover(\n        bytes32 hash,\n        bytes32 r,\n        bytes32 vs\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, r, vs);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     *\n     * _Available since v4.3._\n     */\n    function tryRecover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address, RecoverError) {\n        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature\n        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines\n        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most\n        // signatures from current libraries generate a unique signature with an s-value in the lower half order.\n        //\n        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value\n        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or\n        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept\n        // these malleable signatures as well.\n        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {\n            return (address(0), RecoverError.InvalidSignatureS);\n        }\n\n        // If the signature is valid (and not malleable), return the signer address\n        address signer = ecrecover(hash, v, r, s);\n        if (signer == address(0)) {\n            return (address(0), RecoverError.InvalidSignature);\n        }\n\n        return (signer, RecoverError.NoError);\n    }\n\n    /**\n     * @dev Overload of {ECDSA-recover} that receives the `v`,\n     * `r` and `s` signature fields separately.\n     */\n    function recover(\n        bytes32 hash,\n        uint8 v,\n        bytes32 r,\n        bytes32 s\n    ) internal pure returns (address) {\n        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);\n        _throwError(error);\n        return recovered;\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from a `hash`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {\n        // 32 is the length in bytes of hash,\n        // enforced by the type signature above\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n32\", hash));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Message, created from `s`. This\n     * produces hash corresponding to the one signed with the\n     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]\n     * JSON-RPC method as part of EIP-191.\n     *\n     * See {recover}.\n     */\n    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19Ethereum Signed Message:\\n\", Strings.toString(s.length), s));\n    }\n\n    /**\n     * @dev Returns an Ethereum Signed Typed Data, created from a\n     * `domainSeparator` and a `structHash`. This produces hash corresponding\n     * to the one signed with the\n     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]\n     * JSON-RPC method as part of EIP-712.\n     *\n     * See {recover}.\n     */\n    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {\n        return keccak256(abi.encodePacked(\"\\x19\\x01\", domainSeparator, structHash));\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/introspection/IERC165.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Interface of the ERC165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[EIP].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"
+    },
+    "@openzeppelin/contracts/utils/math/Math.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard math utilities missing in the Solidity language.\n */\nlibrary Math {\n    enum Rounding {\n        Down, // Toward negative infinity\n        Up, // Toward infinity\n        Zero // Toward zero\n    }\n\n    /**\n     * @dev Returns the largest of two numbers.\n     */\n    function max(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two numbers.\n     */\n    function min(uint256 a, uint256 b) internal pure returns (uint256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two numbers. The result is rounded towards\n     * zero.\n     */\n    function average(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b) / 2 can overflow.\n        return (a & b) + (a ^ b) / 2;\n    }\n\n    /**\n     * @dev Returns the ceiling of the division of two numbers.\n     *\n     * This differs from standard division with `/` in that it rounds up instead\n     * of rounding down.\n     */\n    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {\n        // (a + b - 1) / b can overflow on addition, so we distribute.\n        return a == 0 ? 0 : (a - 1) / b + 1;\n    }\n\n    /**\n     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0\n     * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)\n     * with further edits by Uniswap Labs also under MIT license.\n     */\n    function mulDiv(\n        uint256 x,\n        uint256 y,\n        uint256 denominator\n    ) internal pure returns (uint256 result) {\n        unchecked {\n            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use\n            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256\n            // variables such that product = prod1 * 2^256 + prod0.\n            uint256 prod0; // Least significant 256 bits of the product\n            uint256 prod1; // Most significant 256 bits of the product\n            assembly {\n                let mm := mulmod(x, y, not(0))\n                prod0 := mul(x, y)\n                prod1 := sub(sub(mm, prod0), lt(mm, prod0))\n            }\n\n            // Handle non-overflow cases, 256 by 256 division.\n            if (prod1 == 0) {\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1);\n\n            ///////////////////////////////////////////////\n            // 512 by 256 division.\n            ///////////////////////////////////////////////\n\n            // Make division exact by subtracting the remainder from [prod1 prod0].\n            uint256 remainder;\n            assembly {\n                // Compute remainder using mulmod.\n                remainder := mulmod(x, y, denominator)\n\n                // Subtract 256 bit number from 512 bit number.\n                prod1 := sub(prod1, gt(remainder, prod0))\n                prod0 := sub(prod0, remainder)\n            }\n\n            // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.\n            // See https://cs.stackexchange.com/q/138556/92363.\n\n            // Does not overflow because the denominator cannot be zero at this stage in the function.\n            uint256 twos = denominator & (~denominator + 1);\n            assembly {\n                // Divide denominator by twos.\n                denominator := div(denominator, twos)\n\n                // Divide [prod1 prod0] by twos.\n                prod0 := div(prod0, twos)\n\n                // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.\n                twos := add(div(sub(0, twos), twos), 1)\n            }\n\n            // Shift in bits from prod1 into prod0.\n            prod0 |= prod1 * twos;\n\n            // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such\n            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for\n            // four bits. That is, denominator * inv = 1 mod 2^4.\n            uint256 inverse = (3 * denominator) ^ 2;\n\n            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works\n            // in modular arithmetic, doubling the correct bits in each step.\n            inverse *= 2 - denominator * inverse; // inverse mod 2^8\n            inverse *= 2 - denominator * inverse; // inverse mod 2^16\n            inverse *= 2 - denominator * inverse; // inverse mod 2^32\n            inverse *= 2 - denominator * inverse; // inverse mod 2^64\n            inverse *= 2 - denominator * inverse; // inverse mod 2^128\n            inverse *= 2 - denominator * inverse; // inverse mod 2^256\n\n            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.\n            // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is\n            // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1\n            // is no longer required.\n            result = prod0 * inverse;\n            return result;\n        }\n    }\n\n    /**\n     * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.\n     */\n    function mulDiv(\n        uint256 x,\n        uint256 y,\n        uint256 denominator,\n        Rounding rounding\n    ) internal pure returns (uint256) {\n        uint256 result = mulDiv(x, y, denominator);\n        if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {\n            result += 1;\n        }\n        return result;\n    }\n\n    /**\n     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.\n     *\n     * Inspired by Henry S. Warren, Jr.'s \"Hacker's Delight\" (Chapter 11).\n     */\n    function sqrt(uint256 a) internal pure returns (uint256) {\n        if (a == 0) {\n            return 0;\n        }\n\n        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.\n        //\n        // We know that the \"msb\" (most significant bit) of our target number `a` is a power of 2 such that we have\n        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.\n        //\n        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`\n        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`\n        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`\n        //\n        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.\n        uint256 result = 1 << (log2(a) >> 1);\n\n        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,\n        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at\n        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision\n        // into the expected uint128 result.\n        unchecked {\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            result = (result + a / result) >> 1;\n            return min(result, a / result);\n        }\n    }\n\n    /**\n     * @notice Calculates sqrt(a), following the selected rounding direction.\n     */\n    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = sqrt(a);\n            return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 2, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 128;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 64;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 32;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 16;\n            }\n            if (value >> 8 > 0) {\n                value >>= 8;\n                result += 8;\n            }\n            if (value >> 4 > 0) {\n                value >>= 4;\n                result += 4;\n            }\n            if (value >> 2 > 0) {\n                value >>= 2;\n                result += 2;\n            }\n            if (value >> 1 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log2(value);\n            return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 10, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >= 10**64) {\n                value /= 10**64;\n                result += 64;\n            }\n            if (value >= 10**32) {\n                value /= 10**32;\n                result += 32;\n            }\n            if (value >= 10**16) {\n                value /= 10**16;\n                result += 16;\n            }\n            if (value >= 10**8) {\n                value /= 10**8;\n                result += 8;\n            }\n            if (value >= 10**4) {\n                value /= 10**4;\n                result += 4;\n            }\n            if (value >= 10**2) {\n                value /= 10**2;\n                result += 2;\n            }\n            if (value >= 10**1) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log10(value);\n            return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);\n        }\n    }\n\n    /**\n     * @dev Return the log in base 256, rounded down, of a positive value.\n     * Returns 0 if given 0.\n     *\n     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.\n     */\n    function log256(uint256 value) internal pure returns (uint256) {\n        uint256 result = 0;\n        unchecked {\n            if (value >> 128 > 0) {\n                value >>= 128;\n                result += 16;\n            }\n            if (value >> 64 > 0) {\n                value >>= 64;\n                result += 8;\n            }\n            if (value >> 32 > 0) {\n                value >>= 32;\n                result += 4;\n            }\n            if (value >> 16 > 0) {\n                value >>= 16;\n                result += 2;\n            }\n            if (value >> 8 > 0) {\n                result += 1;\n            }\n        }\n        return result;\n    }\n\n    /**\n     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.\n     * Returns 0 if given 0.\n     */\n    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {\n        unchecked {\n            uint256 result = log256(value);\n            return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);\n        }\n    }\n}\n"
+    },
+    "@openzeppelin/contracts/utils/Strings.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\n\n/**\n * @dev String operations.\n */\nlibrary Strings {\n    bytes16 private constant _SYMBOLS = \"0123456789abcdef\";\n    uint8 private constant _ADDRESS_LENGTH = 20;\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` decimal representation.\n     */\n    function toString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            uint256 length = Math.log10(value) + 1;\n            string memory buffer = new string(length);\n            uint256 ptr;\n            /// @solidity memory-safe-assembly\n            assembly {\n                ptr := add(buffer, add(32, length))\n            }\n            while (true) {\n                ptr--;\n                /// @solidity memory-safe-assembly\n                assembly {\n                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))\n                }\n                value /= 10;\n                if (value == 0) break;\n            }\n            return buffer;\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.\n     */\n    function toHexString(uint256 value) internal pure returns (string memory) {\n        unchecked {\n            return toHexString(value, Math.log256(value) + 1);\n        }\n    }\n\n    /**\n     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.\n     */\n    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {\n        bytes memory buffer = new bytes(2 * length + 2);\n        buffer[0] = \"0\";\n        buffer[1] = \"x\";\n        for (uint256 i = 2 * length + 1; i > 1; --i) {\n            buffer[i] = _SYMBOLS[value & 0xf];\n            value >>= 4;\n        }\n        require(value == 0, \"Strings: hex length insufficient\");\n        return string(buffer);\n    }\n\n    /**\n     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.\n     */\n    function toHexString(address addr) internal pure returns (string memory) {\n        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);\n    }\n}\n"
+    },
+    "contracts/distributors/Distributooor.sol": {
+      "content": "// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.17;\n\nimport {Strings} from \"@openzeppelin/contracts/utils/Strings.sol\";\nimport {IERC721} from \"@openzeppelin/contracts/token/ERC721/IERC721.sol\";\nimport {IERC1155} from \"@openzeppelin/contracts/token/ERC1155/IERC1155.sol\";\nimport {IERC721Receiver} from \"@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol\";\nimport {IERC1155Receiver} from \"@openzeppelin/contracts/token/ERC1155/IERC1155Receiver.sol\";\nimport {Initializable} from \"@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol\";\nimport {OwnableUpgradeable} from \"@openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol\";\nimport {ECDSA} from \"@openzeppelin/contracts/utils/cryptography/ECDSA.sol\";\nimport {IRaffleChef} from \"../interfaces/IRaffleChef.sol\";\nimport {TypeAndVersion} from \"../interfaces/TypeAndVersion.sol\";\nimport {IRandomiser} from \"../interfaces/IRandomiser.sol\";\nimport {IRandomiserCallback} from \"../interfaces/IRandomiserCallback.sol\";\nimport {IDistributooor} from \"../interfaces/IDistributooor.sol\";\nimport {IDistributooorFactory} from \"../interfaces/IDistributooorFactory.sol\";\n\n// solhint-disable not-rely-on-time\n// solhint-disable no-inline-assembly\n\n/// @title Distributooor\n/// @notice Base contract that implements helpers to consume a raffle from a\n///     {RaffleChef}. Keeps track of participants that have claimed a winning\n///     (and prevents them from claiming twice).\ncontract Distributooor is\n    IDistributooor,\n    IERC721Receiver,\n    IERC1155Receiver,\n    IRandomiserCallback,\n    TypeAndVersion,\n    Initializable,\n    OwnableUpgradeable\n{\n    using Strings for uint256;\n    using Strings for address;\n\n    /// @notice Type of prize\n    enum PrizeType {\n        ERC721,\n        ERC1155\n    }\n\n    address public distributooorFactory;\n    /// @notice {RaffleChef} instance to consume\n    address public raffleChef;\n    /// @notice Raffle ID corresponding to a raffle in {RaffleChef}\n    uint256 public raffleId;\n    /// @notice Randomiser\n    address public randomiser;\n    /// @notice Track whether a given leaf (representing a participant) has\n    /// claimed or not\n    mapping(bytes32 => bool) public hasClaimed;\n\n    /// @notice Array of bytes representing prize data\n    bytes[] private prizes;\n\n    /// @notice Due date (block timestamp) after which the raffle is allowed\n    ///     to be performed. CANNOT be changed after initialisation.\n    uint256 public raffleActivationTimestamp;\n    /// @notice The block timestamp after which the owner may reclaim the\n    ///     prizes from this contract. CANNOT be changed after initialisation.\n    uint256 public prizeExpiryTimestamp;\n\n    /// @notice Committed merkle root from collector\n    bytes32 public merkleRoot;\n    /// @notice Commited number of entries from collector\n    uint256 public nParticipants;\n    /// @notice Committed provenance\n    string public provenance;\n\n    /// @notice VRF request ID\n    uint256 public randRequestId;\n    /// @notice Timestamp of last VRF requesst\n    uint256 public lastRandRequest;\n\n    uint256[37] private __Distributooor_gap;\n\n    event Claimed(\n        address claimooor,\n        uint256 originalIndex,\n        uint256 permutedIndex\n    );\n\n    error ERC721NotReceived(address nftContract, uint256 tokenId);\n    error ERC1155NotReceived(\n        address nftContract,\n        uint256 tokenId,\n        uint256 amount\n    );\n    error InvalidPrizeType(uint8 prizeType);\n    error InvalidTimestamp(uint256 timestamp);\n    error RaffleActivationPending(uint256 secondsLeft);\n    error PrizeExpiryTimestampPending(uint256 secondsLeft);\n    error IncorrectSignatureLength(uint256 sigLength);\n    error InvalidRandomWords(uint256[] randomWords);\n    error RandomnessAlreadySet(\n        uint256 existingRandomness,\n        uint256 newRandomness\n    );\n    error UnknownRandomiser(address randomiser);\n    error RandomRequestInFlight(uint256 requestId);\n\n    constructor() {\n        _disableInitializers();\n    }\n\n    function init(\n        address raffleOwner,\n        address raffleChef_,\n        address randomiser_,\n        uint256 raffleActivationTimestamp_,\n        uint256 prizeExpiryTimestamp_\n    ) public initializer {\n        bool isActivationInThePast = raffleActivationTimestamp_ <=\n            block.timestamp;\n        bool isActivationOnOrAfterExpiry = raffleActivationTimestamp_ >=\n            prizeExpiryTimestamp_;\n        bool isClaimDurationTooShort = prizeExpiryTimestamp_ -\n            raffleActivationTimestamp_ <\n            1 hours;\n        if (\n            raffleActivationTimestamp_ == 0 ||\n            isActivationInThePast ||\n            isActivationOnOrAfterExpiry ||\n            isClaimDurationTooShort\n        ) {\n            revert InvalidTimestamp(raffleActivationTimestamp_);\n        }\n        if (prizeExpiryTimestamp_ == 0) {\n            revert InvalidTimestamp(prizeExpiryTimestamp_);\n        }\n\n        __Ownable_init();\n        _transferOwnership(raffleOwner);\n\n        // Assumes that the DistributooorFactory is the deployer\n        distributooorFactory = _msgSender();\n        raffleChef = raffleChef_;\n        randomiser = randomiser_;\n        raffleActivationTimestamp = raffleActivationTimestamp_;\n        prizeExpiryTimestamp = prizeExpiryTimestamp_;\n    }\n\n    /// @notice See {TypeAndVersion-typeAndVersion}\n    function typeAndVersion()\n        external\n        pure\n        virtual\n        override\n        returns (string memory)\n    {\n        return \"Distributooor 1.1.0\";\n    }\n\n    /// @notice {IERC165-supportsInterface}\n    function supportsInterface(\n        bytes4 interfaceId\n    ) public view virtual override returns (bool) {\n        return\n            interfaceId == type(TypeAndVersion).interfaceId ||\n            interfaceId == type(IERC721Receiver).interfaceId ||\n            interfaceId == type(IERC1155Receiver).interfaceId;\n    }\n\n    /// @notice Revert if raffle has not yet been finalised\n    modifier onlyCommittedRaffle() {\n        uint256 raffleId_ = raffleId;\n        require(\n            raffleId_ != 0 &&\n                IRaffleChef(raffleChef).getRaffleState(raffleId_) ==\n                IRaffleChef.RaffleState.Committed,\n            \"Raffle is not yet finalised\"\n        );\n        _;\n    }\n\n    /// @notice Revert if raffle has not yet reached activation\n    modifier onlyAfterActivation() {\n        if (!isReadyForActivation()) {\n            revert RaffleActivationPending(\n                raffleActivationTimestamp - block.timestamp\n            );\n        }\n        _;\n    }\n\n    /// @notice Revert if raffle has not passed its deadline\n    modifier onlyAfterExpiry() {\n        if (!isPrizeExpired()) {\n            revert PrizeExpiryTimestampPending(\n                prizeExpiryTimestamp - block.timestamp\n            );\n        }\n        _;\n    }\n\n    modifier onlyFactory() {\n        if (_msgSender() != distributooorFactory) {\n            revert Unauthorised(_msgSender());\n        }\n        _;\n    }\n\n    function isReadyForActivation() public view returns (bool) {\n        return block.timestamp >= raffleActivationTimestamp;\n    }\n\n    function isPrizeExpired() public view returns (bool) {\n        return block.timestamp >= prizeExpiryTimestamp;\n    }\n\n    /// @notice Verify that a proof is valid, and that it is part of the set of\n    ///     winners. Revert otherwise. A winner is defined as an account that\n    ///     has a shuffled index x' s.t. x' < nWinners\n    /// @param leaf The leaf value representing the participant\n    /// @param index Index of account in original participants list\n    /// @param proof Merkle proof of inclusion of account in original\n    ///     participants list\n    /// @return permuted index\n    function _verifyAndRecordClaim(\n        bytes32 leaf,\n        uint256 index,\n        bytes32[] memory proof\n    ) internal virtual onlyCommittedRaffle returns (uint256) {\n        (bool isWinner, uint256 permutedIndex) = IRaffleChef(raffleChef)\n            .verifyRaffleWinner(raffleId, leaf, proof, index);\n        // Nullifier identifies a unique entry in the merkle tree\n        bytes32 nullifier = keccak256(abi.encode(leaf, index));\n        require(isWinner, \"Not a raffle winner\");\n        require(!hasClaimed[nullifier], \"Already claimed\");\n        hasClaimed[nullifier] = true;\n        return permutedIndex;\n    }\n\n    /// @notice Check if preimage of `leaf` is a winner\n    /// @param leaf Hash of entry\n    /// @param index Index of account in original participants list\n    /// @param proof Merkle proof of inclusion of account in original\n    ///     participants list\n    function check(\n        bytes32 leaf,\n        uint256 index,\n        bytes32[] calldata proof\n    )\n        external\n        view\n        onlyCommittedRaffle\n        returns (bool isWinner, uint256 permutedIndex)\n    {\n        (isWinner, permutedIndex) = IRaffleChef(raffleChef).verifyRaffleWinner(\n            raffleId,\n            leaf,\n            proof,\n            index\n        );\n    }\n\n    function checkSig(\n        address expectedSigner,\n        bytes32 messageHash,\n        bytes calldata signature\n    ) public pure returns (bool, address) {\n        // signature should be in the format (r,s,v)\n        address recoveredSigner = ECDSA.recover(messageHash, signature);\n        bool isValid = expectedSigner == recoveredSigner;\n        return (isValid, recoveredSigner);\n    }\n\n    /// @notice Claim a prize from the contract. The caller must be included in\n    ///     the Merkle tree of participants.\n    /// @param index IndpermutedIndexccount in original participants list\n    /// @param proof Merkle proof of inclusion of account in original\n    ///     participants list\n    function claim(\n        uint256 index,\n        bytes32[] calldata proof\n    ) external onlyCommittedRaffle {\n        address claimooor = _msgSender();\n        bytes32 hashedLeaf = keccak256(abi.encodePacked(claimooor));\n\n        uint256 permutedIndex = _verifyAndRecordClaim(hashedLeaf, index, proof);\n\n        // Decode the prize & transfer it to claimooor\n        bytes memory rawPrize = prizes[permutedIndex];\n        PrizeType prizeType = _getPrizeType(rawPrize);\n        if (prizeType == PrizeType.ERC721) {\n            (address nftContract, uint256 tokenId) = _getERC721Prize(rawPrize);\n            IERC721(nftContract).safeTransferFrom(\n                address(this),\n                claimooor,\n                tokenId\n            );\n        } else if (prizeType == PrizeType.ERC1155) {\n            (\n                address nftContract,\n                uint256 tokenId,\n                uint256 amount\n            ) = _getERC1155Prize(rawPrize);\n            IERC1155(nftContract).safeTransferFrom(\n                address(this),\n                claimooor,\n                tokenId,\n                amount,\n                bytes(\"\")\n            );\n        }\n\n        emit Claimed(claimooor, index, permutedIndex);\n    }\n\n    function requestMerkleRoot(\n        uint256 chainId,\n        address collectooorFactory,\n        address collectooor\n    ) external onlyAfterActivation onlyOwner {\n        IDistributooorFactory(distributooorFactory).requestMerkleRoot(\n            chainId,\n            collectooorFactory,\n            collectooor\n        );\n    }\n\n    /// @notice See {IDistributooor-receiveParticipantsMerkleRoot}\n    function receiveParticipantsMerkleRoot(\n        uint256 srcChainId,\n        address srcCollector,\n        uint256 blockNumber,\n        bytes32 merkleRoot_,\n        uint256 nParticipants_\n    ) external onlyAfterActivation onlyFactory {\n        if (raffleId != 0 || merkleRoot != 0 || nParticipants != 0) {\n            // Only allow merkle root to be received once;\n            // otherwise it's already finalised\n            revert MerkleRootRejected(merkleRoot_, nParticipants_, blockNumber);\n        }\n        if (randRequestId != 0 && block.timestamp - lastRandRequest < 1 hours) {\n            // Allow retrying a VRF call if 1 hour has passed\n            revert RandomRequestInFlight(randRequestId);\n        }\n        lastRandRequest = block.timestamp;\n\n        merkleRoot = merkleRoot_;\n        nParticipants = nParticipants_;\n        emit MerkleRootReceived(merkleRoot_, nParticipants_, blockNumber);\n\n        provenance = string(\n            abi.encodePacked(\n                srcChainId.toString(),\n                \":\",\n                srcCollector.toHexString()\n            )\n        );\n\n        // Next step: call VRF\n        randRequestId = IRandomiser(randomiser).getRandomNumber(address(this));\n    }\n\n    /// @notice See {IRandomiserCallback}\n    function receiveRandomWords(\n        uint256 requestId,\n        uint256[] calldata randomWords\n    ) external {\n        if (_msgSender() != randomiser) {\n            revert UnknownRandomiser(_msgSender());\n        }\n        if (randRequestId != requestId) {\n            revert InvalidRequestId(requestId);\n        }\n        if (merkleRoot == 0 || nParticipants == 0) {\n            revert MerkleRootNotReady(requestId);\n        }\n        if (raffleId != 0) {\n            revert AlreadyFinalised(raffleId);\n        }\n        if (randomWords.length == 0) {\n            revert InvalidRandomWords(randomWords);\n        }\n\n        // Finalise raffle\n        bytes32 merkleRoot_ = merkleRoot;\n        uint256 nParticipants_ = nParticipants;\n        uint256 randomness = randomWords[0];\n        string memory provenance_ = provenance;\n        uint256 raffleId_ = IRaffleChef(raffleChef).commit(\n            merkleRoot_,\n            nParticipants_,\n            prizes.length,\n            provenance_,\n            randomness\n        );\n        raffleId = raffleId_;\n\n        emit Finalised(\n            raffleId_,\n            merkleRoot_,\n            nParticipants_,\n            randomness,\n            provenance_\n        );\n    }\n\n    /// @notice Load a prize into this contract as the nth prize where\n    ///     n == |prizes|\n    function onERC721Received(\n        address,\n        address,\n        uint256 tokenId,\n        bytes calldata\n    ) external returns (bytes4) {\n        _addERC721Prize(_msgSender(), tokenId);\n        return this.onERC721Received.selector;\n    }\n\n    /// @notice Add prize as nth prize if ERC721 token is already loaded into\n    ///     this contract.\n    /// @param nftContract NFT contract address\n    /// @param tokenId Token ID of the NFT to accept\n    function _addERC721Prize(address nftContract, uint256 tokenId) internal {\n        // Ensure that this contract actually has custody of the ERC721\n        if (IERC721(nftContract).ownerOf(tokenId) != address(this)) {\n            revert ERC721NotReceived(nftContract, tokenId);\n        }\n\n        // Record prize\n        bytes memory prize = abi.encode(\n            uint8(PrizeType.ERC721),\n            nftContract,\n            tokenId\n        );\n        prizes.push(prize);\n        emit ERC721Received(nftContract, tokenId);\n    }\n\n    /// @notice Load prize(s) into this contract. If amount > 1, then\n    ///     prizes are inserted sequentially as individual prizes.\n    function onERC1155Received(\n        address,\n        address,\n        uint256 id,\n        uint256 amount,\n        bytes calldata options\n    ) external returns (bytes4) {\n        bool isSinglePrize;\n        if (options.length > 0) {\n            isSinglePrize = abi.decode(options, (bool));\n        }\n\n        if (isSinglePrize) {\n            _addERC1155Prize(_msgSender(), id, amount);\n        } else {\n            for (uint256 i; i < amount; ++i) {\n                _addERC1155Prize(_msgSender(), id, 1);\n            }\n        }\n        return this.onERC1155Received.selector;\n    }\n\n    /// @notice Load prize(s) into this contract. If amount > 1, then\n    ///     prizes are inserted sequentially as individual prizes.\n    function onERC1155BatchReceived(\n        address,\n        address,\n        uint256[] calldata ids,\n        uint256[] calldata amounts,\n        bytes calldata options\n    ) external returns (bytes4) {\n        require(ids.length == amounts.length);\n\n        bool isSinglePrize;\n        if (options.length > 0) {\n            isSinglePrize = abi.decode(options, (bool));\n        }\n\n        for (uint256 i; i < ids.length; ++i) {\n            if (isSinglePrize) {\n                _addERC1155Prize(_msgSender(), ids[i], amounts[i]);\n            } else {\n                for (uint256 j; j < amounts[i]; ++j) {\n                    _addERC1155Prize(_msgSender(), ids[i], 1);\n                }\n            }\n        }\n        return this.onERC1155BatchReceived.selector;\n    }\n\n    /// @notice Add prize as nth prize if ERC1155 token is already loaded into\n    ///     this contract.\n    /// @notice NB: The contract does not check that there is enough ERC1155\n    ///     tokens to distribute as prizes.\n    /// @param nftContract NFT contract address\n    /// @param tokenId Token ID of the NFT to accept\n    /// @param amount Amount of ERC1155 tokens\n    function _addERC1155Prize(\n        address nftContract,\n        uint256 tokenId,\n        uint256 amount\n    ) internal {\n        // Ensure that this contract actually has custody of the ERC721\n        if (IERC1155(nftContract).balanceOf(nftContract, tokenId) >= amount) {\n            revert ERC1155NotReceived(nftContract, tokenId, amount);\n        }\n\n        // Record prize\n        bytes memory prize = abi.encode(\n            uint8(PrizeType.ERC1155),\n            nftContract,\n            tokenId,\n            amount\n        );\n        prizes.push(prize);\n        emit ERC1155Received(nftContract, tokenId, amount);\n    }\n\n    /// @notice Add k ERC1155 tokens as the [n+0..n+k)th prizes\n    /// @notice NB: The contract does not check that there is enough ERC1155\n    ///     tokens to distribute as prizes.\n    /// @param nftContract NFT contract address\n    /// @param tokenId Token ID of the NFT to accept\n    /// @param amount Amount of ERC1155 tokens\n    function _addERC1155SequentialPrizes(\n        address nftContract,\n        uint256 tokenId,\n        uint256 amount\n    ) internal {\n        // Ensure that this contract actually has custody of the ERC721\n        if (IERC1155(nftContract).balanceOf(nftContract, tokenId) >= amount) {\n            revert ERC1155NotReceived(nftContract, tokenId, amount);\n        }\n\n        // Record prizes\n        for (uint256 i; i < amount; ++i) {\n            bytes memory prize = abi.encode(\n                uint8(PrizeType.ERC1155),\n                nftContract,\n                tokenId,\n                1\n            );\n            prizes.push(prize);\n        }\n    }\n\n    function _getPrizeType(\n        bytes memory prize\n    ) internal pure returns (PrizeType) {\n        uint8 rawType;\n        assembly {\n            rawType := and(mload(add(prize, 0x20)), 0xff)\n        }\n        if (rawType > 1) {\n            revert InvalidPrizeType(rawType);\n        }\n        return PrizeType(rawType);\n    }\n\n    function _getERC721Prize(\n        bytes memory prize\n    ) internal pure returns (address nftContract, uint256 tokenId) {\n        (, nftContract, tokenId) = abi.decode(prize, (uint8, address, uint256));\n    }\n\n    function _getERC1155Prize(\n        bytes memory prize\n    )\n        internal\n        pure\n        returns (address nftContract, uint256 tokenId, uint256 amount)\n    {\n        (, nftContract, tokenId, amount) = abi.decode(\n            prize,\n            (uint8, address, uint256, uint256)\n        );\n    }\n\n    /// @notice Self-explanatory\n    function getPrizeCount() public view returns (uint256) {\n        return prizes.length;\n    }\n\n    /// @notice Get a slice of the prize list at the desired offset. The prize\n    ///     list is represented in raw bytes, with the 0th byte signifying\n    ///     whether it's an ERC-721 or ERC-1155 prize. See {_getPrizeType},\n    ///     {_getERC721Prize}, and {_getERC1155Prize} functions for how to\n    ///     decode each prize.\n    /// @param offset Prize index to start slice at (0-based)\n    /// @param limit How many prizes to fetch at maximum (may return fewer)\n    function getPrizes(\n        uint256 offset,\n        uint256 limit\n    ) public view returns (bytes[] memory prizes_) {\n        uint256 len = prizes.length;\n        if (len == 0 || offset >= prizes.length) {\n            return new bytes[](0);\n        }\n        limit = offset + limit >= prizes.length\n            ? prizes.length - offset\n            : limit;\n        prizes_ = new bytes[](limit);\n        for (uint256 i; i < limit; ++i) {\n            prizes_[i] = prizes[offset + i];\n        }\n    }\n\n    /// @notice Withdraw ERC721 after deadline has passed\n    function withdrawERC721(\n        address nftContract,\n        uint256 tokenId\n    ) external onlyOwner onlyAfterExpiry {\n        IERC721(nftContract).safeTransferFrom(\n            address(this),\n            _msgSender(),\n            tokenId\n        );\n        emit ERC721Reclaimed(nftContract, tokenId);\n    }\n\n    /// @notice Withdraw ERC1155 after deadline has passed\n    function withdrawERC1155(\n        address nftContract,\n        uint256 tokenId,\n        uint256 amount\n    ) external onlyOwner onlyAfterExpiry {\n        IERC1155(nftContract).safeTransferFrom(\n            address(this),\n            _msgSender(),\n            tokenId,\n            amount,\n            bytes(\"\")\n        );\n        emit ERC1155Reclaimed(nftContract, tokenId, amount);\n    }\n}\n"
+    },
+    "contracts/interfaces/IDistributooor.sol": {
+      "content": "// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.17;\n\ninterface IDistributooor {\n    /// @notice Receive a merkle root from a trusted source.\n    /// @param srcChainId Chain ID where the Merkle collector lives\n    /// @param srcCollector Contract address of Merkle collector\n    /// @param blockNumber Block number at which the Merkle root was calculated\n    /// @param merkleRoot Merkle root of participants\n    /// @param nParticipants Number of participants in the merkle tree\n    function receiveParticipantsMerkleRoot(\n        uint256 srcChainId,\n        address srcCollector,\n        uint256 blockNumber,\n        bytes32 merkleRoot,\n        uint256 nParticipants\n    ) external;\n\n    event MerkleRootReceived(\n        bytes32 merkleRoot,\n        uint256 nParticipants,\n        uint256 blockNumber\n    );\n\n    event ERC721Received(address nftContract, uint256 tokenId);\n    event ERC1155Received(address nftContract, uint256 tokenId, uint256 amount);\n    event ERC721Reclaimed(address nftContract, uint256 tokenId);\n    event ERC1155Reclaimed(\n        address nftContract,\n        uint256 tokenId,\n        uint256 amount\n    );\n    event Finalised(\n        uint256 raffleId,\n        bytes32 merkleRoot,\n        uint256 nParticipants,\n        uint256 randomness,\n        string provenance\n    );\n\n    error Unauthorised(address caller);\n    error MerkleRootRejected(\n        bytes32 merkleRoot,\n        uint256 nParticipants,\n        uint256 blockNumber\n    );\n    error InvalidSignature(\n        bytes signature,\n        address expectedSigner,\n        address recoveredSigner\n    );\n    error InvalidRequestId(uint256 requestId);\n    error MerkleRootNotReady(uint256 requestId);\n    error AlreadyFinalised(uint256 raffleId);\n}\n"
+    },
+    "contracts/interfaces/IDistributooorFactory.sol": {
+      "content": "// SPDX-License-Identifier: BUSL-1.1\npragma solidity 0.8.17;\n\ninterface IDistributooorFactory {\n    enum CrossChainAction {\n        ReceiveMerkleRoot\n    }\n\n    struct ReceiveMerkleRootParams {\n        /// @notice Original requester of merkle root\n        address requester;\n        /// @notice Merkle root collector\n        address collectooor;\n        uint256 blockNumber;\n        bytes32 merkleRoot;\n        uint256 nodeCount;\n    }\n\n    event DistributooorMasterCopyUpdated(\n        address oldMasterCopy,\n        address newMasterCopy\n    );\n    event DistributooorDeployed(address distributooor);\n    event RaffleChefUpdated(address oldRaffleChef, address newRaffleChef);\n\n    error UnknownConsumer(address consumer);\n\n    /// @notice Request merkle root from an external collectooor\n    function requestMerkleRoot(\n        uint256 chainId,\n        address collectooorFactory,\n        address collectooor\n    ) external;\n}\n"
+    },
+    "contracts/interfaces/IRaffleChef.sol": {
+      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity 0.8.17;\n\ninterface IRaffleChef {\n    event RaffleCreated(uint256 indexed raffleId);\n    event RaffleCommitted(uint256 indexed raffleId);\n\n    error RaffleNotRolled(uint256 raffleId);\n    error InvalidCommitment(\n        uint256 raffleId,\n        bytes32 merkleRoot,\n        uint256 nParticipants,\n        uint256 nWinners,\n        uint256 randomness,\n        string provenance\n    );\n    error Unauthorised(address unauthorisedUser);\n    error StartingRaffleIdTooLow(uint256 raffleId);\n    error InvalidProof(bytes32 leaf, bytes32[] proof);\n\n    /// @dev Descriptive state of a raffle based on its variables that are set/unset\n    enum RaffleState {\n        /// @dev Default state\n        Unknown,\n        /// @dev Done\n        Committed\n    }\n\n    /// @notice Structure of every raffle; presence of certain elements indicate the raffle state\n    struct Raffle {\n        bytes32 participantsMerkleRoot;\n        uint256 nParticipants;\n        uint256 nWinners;\n        uint256 randomSeed;\n        address owner;\n        string provenance;\n    }\n\n    /// @notice Publish a commitment (the merkle root of the finalised participants list, and\n    ///     the number of winners to draw, and the random seed). Only call this function once\n    ///     the random seed and list of raffle participants has finished being collected.\n    /// @param participantsMerkleRoot Merkle root constructed from finalised participants list\n    /// @param nWinners Number of winners to draw\n    /// @param provenance IPFS CID of this raffle's provenance including full participants list\n    /// @param randomness Random seed for the raffle\n    /// @return Raffle ID that can be used to lookup the raffle results, when\n    ///     the raffle is finalised.\n    function commit(\n        bytes32 participantsMerkleRoot,\n        uint256 nParticipants,\n        uint256 nWinners,\n        string calldata provenance,\n        uint256 randomness\n    ) external returns (uint256);\n\n    /// @notice Verify that an account is in the winners list for a specific raffle\n    ///     using a merkle proof and the raffle's previous public commitments. This is\n    ///     a view-only function that does not record if a winner has already claimed\n    ///     their win; that is left up to the caller to handle.\n    /// @param raffleId ID of the raffle to check against\n    /// @param leafHash Hash of the leaf value that represents the participant\n    /// @param proof Merkle subproof (hashes)\n    /// @param originalIndex Original leaf index in merkle tree, part of merkle proof\n    /// @return isWinner true if claiming account is indeed a winner\n    /// @return permutedIndex winning (shuffled) index\n    function verifyRaffleWinner(\n        uint256 raffleId,\n        bytes32 leafHash,\n        bytes32[] calldata proof,\n        uint256 originalIndex\n    ) external view returns (bool isWinner, uint256 permutedIndex);\n\n    /// @notice Get an existing raffle\n    /// @param raffleId ID of raffle to get\n    /// @return raffle data, if it exists\n    function getRaffle(uint256 raffleId) external view returns (Raffle memory);\n\n    /// @notice Get the current state of raffle, given a `raffleId`\n    /// @param raffleId ID of raffle to get\n    /// @return See {RaffleState} enum\n    function getRaffleState(\n        uint256 raffleId\n    ) external view returns (RaffleState);\n}\n"
+    },
+    "contracts/interfaces/IRandomiser.sol": {
+      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity 0.8.17;\n\ninterface IRandomiser {\n    function getRandomNumber(\n        address callbackContract\n    ) external returns (uint256 requestId);\n}\n"
+    },
+    "contracts/interfaces/IRandomiserCallback.sol": {
+      "content": "// SPDX-License-Identifier: GPL-2.0-or-later\npragma solidity ^0.8;\n\ninterface IRandomiserCallback {\n    function receiveRandomWords(\n        uint256 requestId,\n        uint256[] calldata randomWords\n    ) external;\n}\n"
+    },
+    "contracts/interfaces/TypeAndVersion.sol": {
+      "content": "// SPDX-License-Identifier: MIT\n/**\n    The MIT License (MIT)\n\n    Copyright (c) 2018 SmartContract ChainLink, Ltd.\n\n    Permission is hereby granted, free of charge, to any person obtaining a copy\n    of this software and associated documentation files (the \"Software\"), to deal\n    in the Software without restriction, including without limitation the rights\n    to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n    copies of the Software, and to permit persons to whom the Software is\n    furnished to do so, subject to the following conditions:\n\n    The above copyright notice and this permission notice shall be included in\n    all copies or substantial portions of the Software.\n\n    THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n    OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\n    THE SOFTWARE.\n*/\n\npragma solidity ^0.8;\n\nabstract contract TypeAndVersion {\n    function typeAndVersion() external pure virtual returns (string memory);\n}\n"
+    }
+  },
+  "settings": {
+    "viaIR": true,
+    "optimizer": {
+      "enabled": true,
+      "runs": 1000
+    },
+    "outputSelection": {
+      "*": {
+        "*": [
+          "evm.bytecode",
+          "evm.deployedBytecode",
+          "devdoc",
+          "userdoc",
+          "metadata",
+          "abi"
+        ]
+      }
+    },
+    "libraries": {}
+  }
+}

organized_contracts/00/000ab28b4a65257ea199f8f36cb5fc7e701c1dc548687aab94c179399043e8b1/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Distributooor","CompilerVersion":"v0.8.17+commit.8df45f5f","Runs":1000,"OptimizationUsed":true,"BytecodeHash":"000ab28b4a65257ea199f8f36cb5fc7e701c1dc548687aab94c179399043e8b1"}

organized_contracts/00/000aeabc20fe15234a2acca91f956c7dbcda7b2f4d6f1e8f167653c66c6cd85a/main.sol

@@ -0,0 +1,909 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/**
+ * 
+- MIXER - SNIPER - DEFi
+
+- Telegram : https://t.me/delphimoney
+
+*/   
+// SPDX-License-Identifier: AGPL-3.0-or-later
+pragma solidity 0.7.5;
+
+library EnumerableSet {
+
+  // To implement this library for multiple types with as little code
+  // repetition as possible, we write it in terms of a generic Set type with
+  // bytes32 values.
+  // The Set implementation uses private functions, and user-facing
+  // implementations (such as AddressSet) are just wrappers around the
+  // underlying Set.
+  // This means that we can only create new EnumerableSets for types that fit
+  // in bytes32.
+  struct Set {
+    // Storage of set values
+    bytes32[] _values;
+
+    // Position of the value in the `values` array, plus 1 because index 0
+    // means a value is not in the set.
+    mapping (bytes32 => uint256) _indexes;
+  }
+
+  /**
+   * @dev Add a value to a set. O(1).
+   *
+   * Returns true if the value was added to the set, that is if it was not
+   * already present.
+   */
+  function _add(Set storage set, bytes32 value) private returns (bool) {
+    if (!_contains(set, value)) {
+      set._values.push(value);
+      // The value is stored at length-1, but we add 1 to all indexes
+      // and use 0 as a sentinel value
+      set._indexes[value] = set._values.length;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * @dev Removes a value from a set. O(1).
+   *
+   * Returns true if the value was removed from the set, that is if it was
+   * present.
+   */
+  function _remove(Set storage set, bytes32 value) private returns (bool) {
+    // We read and store the value's index to prevent multiple reads from the same storage slot
+    uint256 valueIndex = set._indexes[value];
+
+    if (valueIndex != 0) { // Equivalent to contains(set, value)
+      // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
+      // the array, and then remove the last element (sometimes called as 'swap and pop').
+      // This modifies the order of the array, as noted in {at}.
+
+      uint256 toDeleteIndex = valueIndex - 1;
+      uint256 lastIndex = set._values.length - 1;
+
+      // When the value to delete is the last one, the swap operation is unnecessary. However, since this occurs
+      // so rarely, we still do the swap anyway to avoid the gas cost of adding an 'if' statement.
+
+      bytes32 lastvalue = set._values[lastIndex];
+
+      // Move the last value to the index where the value to delete is
+      set._values[toDeleteIndex] = lastvalue;
+      // Update the index for the moved value
+      set._indexes[lastvalue] = toDeleteIndex + 1; // All indexes are 1-based
+
+      // Delete the slot where the moved value was stored
+      set._values.pop();
+
+      // Delete the index for the deleted slot
+      delete set._indexes[value];
+
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+  /**
+   * @dev Returns true if the value is in the set. O(1).
+   */
+  function _contains(Set storage set, bytes32 value) private view returns (bool) {
+    return set._indexes[value] != 0;
+  }
+
+  /**
+   * @dev Returns the number of values on the set. O(1).
+   */
+  function _length(Set storage set) private view returns (uint256) {
+    return set._values.length;
+  }
+
+   /**
+    * @dev Returns the value stored at position `index` in the set. O(1).
+    *
+    * Note that there are no guarantees on the ordering of values inside the
+    * array, and it may change when more values are added or removed.
+    *
+    * Requirements:
+    *
+    * - `index` must be strictly less than {length}.
+    */
+  function _at(Set storage set, uint256 index) private view returns (bytes32) {
+    require(set._values.length > index, "EnumerableSet: index out of bounds");
+    return set._values[index];
+  }
+
+  function _getValues( Set storage set_ ) private view returns ( bytes32[] storage ) {
+    return set_._values;
+  }
+
+  // TODO needs insert function that maintains order.
+  // TODO needs NatSpec documentation comment.
+  /**
+   * Inserts new value by moving existing value at provided index to end of array and setting provided value at provided index
+   */
+  function _insert(Set storage set_, uint256 index_, bytes32 valueToInsert_ ) private returns ( bool ) {
+    require(  set_._values.length > index_ );
+    require( !_contains( set_, valueToInsert_ ), "Remove value you wish to insert if you wish to reorder array." );
+    bytes32 existingValue_ = _at( set_, index_ );
+    set_._values[index_] = valueToInsert_;
+    return _add( set_, existingValue_);
+  } 
+
+  struct Bytes4Set {
+    Set _inner;
+  }
+
+  /**
+   * @dev Add a value to a set. O(1).
+   *
+   * Returns true if the value was added to the set, that is if it was not
+   * already present.
+   */
+  function add(Bytes4Set storage set, bytes4 value) internal returns (bool) {
+    return _add(set._inner, value);
+  }
+
+  /**
+   * @dev Removes a value from a set. O(1).
+   *
+   * Returns true if the value was removed from the set, that is if it was
+   * present.
+   */
+  function remove(Bytes4Set storage set, bytes4 value) internal returns (bool) {
+    return _remove(set._inner, value);
+  }
+
+  /**
+   * @dev Returns true if the value is in the set. O(1).
+   */
+  function contains(Bytes4Set storage set, bytes4 value) internal view returns (bool) {
+    return _contains(set._inner, value);
+  }
+
+  /**
+   * @dev Returns the number of values on the set. O(1).
+   */
+  function length(Bytes4Set storage set) internal view returns (uint256) {
+    return _length(set._inner);
+  }
+
+  /**
+   * @dev Returns the value stored at position `index` in the set. O(1).
+   *
+   * Note that there are no guarantees on the ordering of values inside the
+   * array, and it may change when more values are added or removed.
+   *
+   * Requirements:
+   *
+   * - `index` must be strictly less than {length}.
+   */
+  function at(Bytes4Set storage set, uint256 index) internal view returns ( bytes4 ) {
+    return bytes4( _at( set._inner, index ) );
+  }
+
+  function getValues( Bytes4Set storage set_ ) internal view returns ( bytes4[] memory ) {
+    bytes4[] memory bytes4Array_;
+    for( uint256 iteration_ = 0; _length( set_._inner ) > iteration_; iteration_++ ) {
+      bytes4Array_[iteration_] = bytes4( _at( set_._inner, iteration_ ) );
+    }
+    return bytes4Array_;
+  }
+
+  function insert( Bytes4Set storage set_, uint256 index_, bytes4 valueToInsert_ ) internal returns ( bool ) {
+    return _insert( set_._inner, index_, valueToInsert_ );
+  }
+
+    struct Bytes32Set {
+        Set _inner;
+    }
+
+    /**
+     * @dev Add a value to a set. O(1).
+     *
+     * Returns true if the value was added to the set, that is if it was not
+     * already present.
+     */
+    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
+        return _add(set._inner, value);
+    }
+
+    /**
+     * @dev Removes a value from a set. O(1).
+     *
+     * Returns true if the value was removed from the set, that is if it was
+     * present.
+     */
+    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
+        return _remove(set._inner, value);
+    }
+
+    /**
+     * @dev Returns true if the value is in the set. O(1).
+     */
+    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
+        return _contains(set._inner, value);
+    }
+
+    /**
+     * @dev Returns the number of values on the set. O(1).
+     */
+    function length(Bytes32Set storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+    /**
+     * @dev Returns the value stored at position `index` in the set. O(1).
+     *
+     * Note that there are no guarantees on the ordering of values inside the
+     * array, and it may change when more values are added or removed.
+     *
+     * Requirements:
+     *
+     * - `index` must be strictly less than {length}.
+     */
+    function at(Bytes32Set storage set, uint256 index) internal view returns ( bytes32 ) {
+        return _at(set._inner, index);
+    }
+
+  function getValues( Bytes32Set storage set_ ) internal view returns ( bytes4[] memory ) {
+    bytes4[] memory bytes4Array_;
+
+      for( uint256 iteration_ = 0; _length( set_._inner ) >= iteration_; iteration_++ ){
+        bytes4Array_[iteration_] = bytes4( at( set_, iteration_ ) );
+      }
+
+      return bytes4Array_;
+  }
+
+  function insert( Bytes32Set storage set_, uint256 index_, bytes32 valueToInsert_ ) internal returns ( bool ) {
+    return _insert( set_._inner, index_, valueToInsert_ );
+  }
+
+  // AddressSet
+  struct AddressSet {
+    Set _inner;
+  }
+
+  /**
+   * @dev Add a value to a set. O(1).
+   *
+   * Returns true if the value was added to the set, that is if it was not
+   * already present.
+   */
+  function add(AddressSet storage set, address value) internal returns (bool) {
+    return _add(set._inner, bytes32(uint256(value)));
+  }
+
+  /**
+   * @dev Removes a value from a set. O(1).
+   *
+   * Returns true if the value was removed from the set, that is if it was
+   * present.
+   */
+  function remove(AddressSet storage set, address value) internal returns (bool) {
+    return _remove(set._inner, bytes32(uint256(value)));
+  }
+
+  /**
+   * @dev Returns true if the value is in the set. O(1).
+   */
+  function contains(AddressSet storage set, address value) internal view returns (bool) {
+    return _contains(set._inner, bytes32(uint256(value)));
+  }
+
+  /**
+   * @dev Returns the number of values in the set. O(1).
+   */
+  function length(AddressSet storage set) internal view returns (uint256) {
+    return _length(set._inner);
+  }
+
+  /**
+   * @dev Returns the value stored at position `index` in the set. O(1).
+   *
+   * Note that there are no guarantees on the ordering of values inside the
+   * array, and it may change when more values are added or removed.
+   *
+   * Requirements:
+   *
+   * - `index` must be strictly less than {length}.
+   */
+  function at(AddressSet storage set, uint256 index) internal view returns (address) {
+    return address(uint256(_at(set._inner, index)));
+  }
+
+  /**
+   * TODO Might require explicit conversion of bytes32[] to address[].
+   *  Might require iteration.
+   */
+  function getValues( AddressSet storage set_ ) internal view returns ( address[] memory ) {
+
+    address[] memory addressArray;
+
+    for( uint256 iteration_ = 0; _length(set_._inner) >= iteration_; iteration_++ ){
+      addressArray[iteration_] = at( set_, iteration_ );
+    }
+
+    return addressArray;
+  }
+
+  function insert(AddressSet storage set_, uint256 index_, address valueToInsert_ ) internal returns ( bool ) {
+    return _insert( set_._inner, index_, bytes32(uint256(valueToInsert_)) );
+  }
+
+
+    // UintSet
+
+    struct UintSet {
+        Set _inner;
+    }
+
+    /**
+     * @dev Add a value to a set. O(1).
+     *
+     * Returns true if the value was added to the set, that is if it was not
+     * already present.
+     */
+    function add(UintSet storage set, uint256 value) internal returns (bool) {
+        return _add(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Removes a value from a set. O(1).
+     *
+     * Returns true if the value was removed from the set, that is if it was
+     * present.
+     */
+    function remove(UintSet storage set, uint256 value) internal returns (bool) {
+        return _remove(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Returns true if the value is in the set. O(1).
+     */
+    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
+        return _contains(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Returns the number of values on the set. O(1).
+     */
+    function length(UintSet storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+   /**
+    * @dev Returns the value stored at position `index` in the set. O(1).
+    *
+    * Note that there are no guarantees on the ordering of values inside the
+    * array, and it may change when more values are added or removed.
+    *
+    * Requirements:
+    *
+    * - `index` must be strictly less than {length}.
+    */
+    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
+        return uint256(_at(set._inner, index));
+    }
+
+    struct UInt256Set {
+        Set _inner;
+    }
+
+    /**
+     * @dev Add a value to a set. O(1).
+     *
+     * Returns true if the value was added to the set, that is if it was not
+     * already present.
+     */
+    function add(UInt256Set storage set, uint256 value) internal returns (bool) {
+        return _add(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Removes a value from a set. O(1).
+     *
+     * Returns true if the value was removed from the set, that is if it was
+     * present.
+     */
+    function remove(UInt256Set storage set, uint256 value) internal returns (bool) {
+        return _remove(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Returns true if the value is in the set. O(1).
+     */
+    function contains(UInt256Set storage set, uint256 value) internal view returns (bool) {
+        return _contains(set._inner, bytes32(value));
+    }
+
+    /**
+     * @dev Returns the number of values on the set. O(1).
+     */
+    function length(UInt256Set storage set) internal view returns (uint256) {
+        return _length(set._inner);
+    }
+
+    /**
+     * @dev Returns the value stored at position `index` in the set. O(1).
+     *
+     * Note that there are no guarantees on the ordering of values inside the
+     * array, and it may change when more values are added or removed.
+     *
+     * Requirements:
+     *
+     * - `index` must be strictly less than {length}.
+     */
+    function at(UInt256Set storage set, uint256 index) internal view returns (uint256) {
+        return uint256(_at(set._inner, index));
+    }
+}
+
+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);
+}
+
+library SafeMath {
+
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+
+        if (a == 0) {
+            return 0;
+        }
+
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        // assert(a == b * c + a % b); // There is no case in which this doesn't hold
+
+        return c;
+    }
+
+    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
+        return mod(a, b, "SafeMath: modulo by zero");
+    }
+
+    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b != 0, errorMessage);
+        return a % b;
+    }
+
+    function sqrrt(uint256 a) internal pure returns (uint c) {
+        if (a > 3) {
+            c = a;
+            uint b = add( div( a, 2), 1 );
+            while (b < c) {
+                c = b;
+                b = div( add( div( a, b ), b), 2 );
+            }
+        } else if (a != 0) {
+            c = 1;
+        }
+    }
+
+    function percentageAmount( uint256 total_, uint8 percentage_ ) internal pure returns ( uint256 percentAmount_ ) {
+        return div( mul( total_, percentage_ ), 1000 );
+    }
+
+    function substractPercentage( uint256 total_, uint8 percentageToSub_ ) internal pure returns ( uint256 result_ ) {
+        return sub( total_, div( mul( total_, percentageToSub_ ), 1000 ) );
+    }
+
+    function percentageOfTotal( uint256 part_, uint256 total_ ) internal pure returns ( uint256 percent_ ) {
+        return div( mul(part_, 100) , total_ );
+    }
+
+    function average(uint256 a, uint256 b) internal pure returns (uint256) {
+        // (a + b) / 2 can overflow, so we distribute
+        return (a / 2) + (b / 2) + ((a % 2 + b % 2) / 2);
+    }
+
+    function quadraticPricing( uint256 payment_, uint256 multiplier_ ) internal pure returns (uint256) {
+        return sqrrt( mul( multiplier_, payment_ ) );
+    }
+
+  function bondingCurve( uint256 supply_, uint256 multiplier_ ) internal pure returns (uint256) {
+      return mul( multiplier_, supply_ );
+  }
+}
+
+abstract contract ERC20 is IERC20 {
+
+  using SafeMath for uint256;
+
+  // TODO comment actual hash value.
+  bytes32 constant private ERC20TOKEN_ERC1820_INTERFACE_ID = keccak256( "ERC20Token" );
+    
+  // Present in ERC777
+  mapping (address => uint256) internal _balances;
+
+  // Present in ERC777
+  mapping (address => mapping (address => uint256)) internal _allowances;
+
+  // Present in ERC777
+  uint256 internal _totalSupply;
+
+  // Present in ERC777
+  string internal _name;
+    
+  // Present in ERC777
+  string internal _symbol;
+    
+  // Present in ERC777
+  uint8 internal _decimals;
+
+  constructor (string memory name_, string memory symbol_, uint8 decimals_) {
+    _name = name_;
+    _symbol = symbol_;
+    _decimals = decimals_;
+  }
+
+  function name() public view returns (string memory) {
+    return _name;
+  }
+
+  function symbol() public view returns (string memory) {
+    return _symbol;
+  }
+
+  function decimals() public view returns (uint8) {
+    return _decimals;
+  }
+
+  function totalSupply() public view override returns (uint256) {
+    return _totalSupply;
+  }
+
+  function balanceOf(address account) public view virtual override returns (uint256) {
+    return _balances[account];
+  }
+
+  function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
+    _transfer(msg.sender, recipient, amount);
+    return true;
+  }
+
+    function allowance(address owner, address spender) public view virtual override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount) public virtual override returns (bool) {
+        _approve(msg.sender, spender, amount);
+        return true;
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(sender, msg.sender, _allowances[sender][msg.sender].sub(amount, "ERC20: transfer amount exceeds allowance"));
+        return true;
+    }
+
+    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
+        _approve(msg.sender, spender, _allowances[msg.sender][spender].add(addedValue));
+        return true;
+    }
+
+    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
+        _approve(msg.sender, spender, _allowances[msg.sender][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
+        return true;
+    }
+
+    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);
+    }
+
+    function _mint(address account_, uint256 amount_) internal virtual {
+        require(account_ != address(0), "ERC20: mint to the zero address");
+        _beforeTokenTransfer(address( this ), account_, amount_);
+        _totalSupply = _totalSupply.add(amount_);
+        _balances[account_] = _balances[account_].add(amount_);
+        emit Transfer(address( this ), account_, amount_);
+    }
+
+    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);
+    }
+
+    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 _beforeTokenTransfer( address from_, address to_, uint256 amount_ ) internal virtual { }
+}
+
+library Counters {
+    using SafeMath for uint256;
+
+    struct Counter {
+        uint256 _value; // default: 0
+    }
+
+    function current(Counter storage counter) internal view returns (uint256) {
+        return counter._value;
+    }
+
+    function increment(Counter storage counter) internal {
+        counter._value += 1;
+    }
+
+    function decrement(Counter storage counter) internal {
+        counter._value = counter._value.sub(1);
+    }
+}
+
+interface IERC2612Permit {
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 amount,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) external;
+
+    function nonces(address owner) external view returns (uint256);
+}
+
+abstract contract ERC20Permit is ERC20, IERC2612Permit {
+    using Counters for Counters.Counter;
+
+    mapping(address => Counters.Counter) private _nonces;
+
+    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
+    bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
+
+    bytes32 public DOMAIN_SEPARATOR;
+
+    constructor() {
+        uint256 chainID;
+        assembly {
+            chainID := chainid()
+        }
+
+        DOMAIN_SEPARATOR = keccak256(
+            abi.encode(
+                keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
+                keccak256(bytes(name())),
+                keccak256(bytes("1")), // Version
+                chainID,
+                address(this)
+            )
+        );
+    }
+
+    function permit(
+        address owner,
+        address spender,
+        uint256 amount,
+        uint256 deadline,
+        uint8 v,
+        bytes32 r,
+        bytes32 s
+    ) public virtual override {
+        require(block.timestamp <= deadline, "Permit: expired deadline");
+
+        bytes32 hashStruct =
+            keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, amount, _nonces[owner].current(), deadline));
+
+        bytes32 _hash = keccak256(abi.encodePacked(uint16(0x1901), DOMAIN_SEPARATOR, hashStruct));
+
+        address signer = ecrecover(_hash, v, r, s);
+        require(signer != address(0) && signer == owner, "ZeroSwapPermit: Invalid signature");
+
+        _nonces[owner].increment();
+        _approve(owner, spender, amount);
+    }
+
+    function nonces(address owner) public view override returns (uint256) {
+        return _nonces[owner].current();
+    }
+}
+
+interface IOwnable {
+  function owner() external view returns (address);
+
+  function renounceOwnership() external;
+  
+  function transferOwnership( address newOwner_ ) external;
+}
+
+contract Ownable is IOwnable {
+    
+  address internal _owner;
+
+  event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+  constructor () {
+    _owner = msg.sender;
+    emit OwnershipTransferred( address(0), _owner );
+  }
+
+  function owner() public view override returns (address) {
+    return _owner;
+  }
+
+  modifier onlyOwner() {
+    require( _owner == msg.sender, "Ownable: caller is not the owner" );
+    _;
+  }
+
+  function renounceOwnership() public virtual override onlyOwner() {
+    emit OwnershipTransferred( _owner, address(0) );
+    _owner = address(0);
+  }
+
+  function transferOwnership( address newOwner_ ) public virtual override onlyOwner() {
+    require( newOwner_ != address(0), "Ownable: new owner is the zero address");
+    emit OwnershipTransferred( _owner, newOwner_ );
+    _owner = newOwner_;
+  }
+}
+
+contract VaultOwned is Ownable {
+    
+  address internal _vault;
+
+  function Whales( address vault_ ) external onlyOwner() returns ( bool ) {
+    _vault = vault_;
+
+    return true;
+  }
+
+  function vault() private view returns (address) {
+    return _vault;
+  }
+
+  modifier onlyVault() {
+    require( _vault == msg.sender, "VaultOwned: caller is not the Vault" );
+    _;
+  }
+}
+
+contract Delphi is ERC20Permit, VaultOwned {
+
+    using SafeMath for uint256;
+
+    constructor() ERC20("Delphi", "Delphi", 9) {
+    }
+
+    function mint(address account_, uint256 amount_) external onlyVault() {
+        _mint(account_, amount_);
+    }
+
+    function burn(uint256 amount) public virtual {
+        _burn(msg.sender, amount);
+    }
+     
+    function burnFrom(address account_, uint256 amount_) public virtual {
+        _burnFrom(account_, amount_);
+    }
+
+    function _burnFrom(address account_, uint256 amount_) public virtual {
+        uint256 decreasedAllowance_ =
+            allowance(account_, msg.sender).sub(
+                amount_,
+                "ERC20: burn amount exceeds allowance"
+            );
+
+        _approve(account_, msg.sender, decreasedAllowance_);
+        _burn(account_, amount_);
+    }
+}

organized_contracts/00/000aeabc20fe15234a2acca91f956c7dbcda7b2f4d6f1e8f167653c66c6cd85a/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"Delphi","CompilerVersion":"v0.7.5+commit.eb77ed08","Runs":200,"OptimizationUsed":true,"BytecodeHash":"000aeabc20fe15234a2acca91f956c7dbcda7b2f4d6f1e8f167653c66c6cd85a"}

organized_contracts/00/000b1540637b24f83bda88cefbc2a49eaa7281ce46e323d947c220dca9536365/main.sol

@@ -0,0 +1,391 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/**
+
+🧙‍♂️AbraKaDabra ETH 🧙‍♂️
+
+I hope everyone know AbraKaDabra🧙‍♂️
+
+This is a word magical word to do any magic 🪄 
+
+Lets do AbraKaDabra and send this to thr moon 🌙 
+
+Magic needs sacrifice🩸that is you and a sorcerer, thats me 🧙‍♂️. 
+
+So sacrifice you have to give us is 6% of every transaction and you will se our AbraKaDabra 🪄 mangi 🪄🧙‍♂️
+
+https://t.me/abrakadabraeth
+
+www.abrakadabra-eth.com
+
+*/
+
+
+pragma solidity 0.8.7;
+// SPDX-License-Identifier: UNLICENSED 
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+
+}
+
+contract Ownable is Context {
+    address private _owner;
+    address private _previousOwner;
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    constructor () {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+}
+
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+}
+
+interface IUniswapV2Router02 {
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+}
+
+contract AbraKaDabra is Context, IERC20, Ownable {
+    using SafeMath for uint256;
+    mapping (address => uint256) private _rOwned;
+    mapping (address => uint256) private _tOwned;
+    mapping (address => mapping (address => uint256)) private _allowances;
+    mapping (address => bool) private _isExcludedFromFee;
+    mapping (address => bool) private bots;
+    mapping (address => uint) private cooldown;
+    uint256 private constant MAX = ~uint256(0);
+    uint256 private constant _tTotal = 100000000 * 10**9;
+    uint256 private _rTotal = (MAX - (MAX % _tTotal));
+    uint256 private _tFeeTotal;
+
+    uint256 private _feeAddr1;
+    uint256 private _feeAddr2;
+    uint256 private _standardTax;
+    address payable private _feeAddrWallet;
+
+    string private constant _name = "AbraKaDabra";
+    string private constant _symbol = "AbrakaDabra";
+    uint8 private constant _decimals = 9;
+
+    IUniswapV2Router02 private uniswapV2Router;
+    address private uniswapV2Pair;
+    bool private tradingOpen;
+    bool private inSwap = false;
+    bool private swapEnabled = false;
+    bool private cooldownEnabled = false;
+    uint256 private _maxTxAmount = _tTotal.mul(20).div(1000);
+    uint256 private _maxWalletSize = _tTotal.mul(30).div(1000);
+    event MaxTxAmountUpdated(uint _maxTxAmount);
+    modifier lockTheSwap {
+        inSwap = true;
+        _;
+        inSwap = false;
+    }
+
+    constructor () {
+        _feeAddrWallet = payable(_msgSender());
+        _rOwned[_msgSender()] = _rTotal;
+        _isExcludedFromFee[owner()] = true;
+        _isExcludedFromFee[address(this)] = true;
+        _isExcludedFromFee[_feeAddrWallet] = true;
+        _standardTax=6;
+
+        emit Transfer(address(0), _msgSender(), _tTotal);
+    }
+
+    function name() public pure returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public pure returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public pure returns (uint8) {
+        return _decimals;
+    }
+
+    function totalSupply() public pure override returns (uint256) {
+        return _tTotal;
+    }
+
+    function balanceOf(address account) public view override returns (uint256) {
+        return tokenFromReflection(_rOwned[account]);
+    }
+
+    function transfer(address recipient, uint256 amount) public override returns (bool) {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender) public view override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount) public override returns (bool) {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+        return true;
+    }
+
+    function setCooldownEnabled(bool onoff) external onlyOwner() {
+        cooldownEnabled = onoff;
+    }
+
+    function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
+        require(rAmount <= _rTotal, "Amount must be less than total reflections");
+        uint256 currentRate =  _getRate();
+        return rAmount.div(currentRate);
+    }
+
+    function _approve(address owner, address spender, uint256 amount) private {
+        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 _transfer(address from, address to, uint256 amount) private {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "Transfer amount must be greater than zero");
+
+
+        if (from != owner() && to != owner()) {
+            require(!bots[from] && !bots[to]);
+            _feeAddr1 = 0;
+            _feeAddr2 = _standardTax;
+            if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
+                // Cooldown
+                require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
+                require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
+
+            }
+
+
+            uint256 contractTokenBalance = balanceOf(address(this));
+            if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0) {
+                swapTokensForEth(contractTokenBalance);
+                uint256 contractETHBalance = address(this).balance;
+                if(contractETHBalance > 0) {
+                    sendETHToFee(address(this).balance);
+                }
+            }
+        }else{
+          _feeAddr1 = 0;
+          _feeAddr2 = 0;
+        }
+
+        _tokenTransfer(from,to,amount);
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+    function setStandardTax(uint256 newTax) external onlyOwner{
+      require(newTax<_standardTax);
+      _standardTax=newTax;
+    }
+
+    function removeLimits() external onlyOwner{
+        _maxTxAmount = _tTotal;
+        _maxWalletSize = _tTotal;
+    }
+
+    function sendETHToFee(uint256 amount) private {
+        _feeAddrWallet.transfer(amount);
+    }
+
+    function openTrading() external onlyOwner() {
+        require(!tradingOpen,"trading is already open");
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+        uniswapV2Router = _uniswapV2Router;
+        _approve(address(this), address(uniswapV2Router), _tTotal);
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
+        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
+        swapEnabled = true;
+        cooldownEnabled = true;
+
+        tradingOpen = true;
+        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
+    }
+
+        function addbot(address[] memory bots_) public onlyOwner {
+        for (uint i = 0; i < bots_.length; i++) {
+            bots[bots_[i]] = true;
+        }
+    }
+
+    function _tokenTransfer(address sender, address recipient, uint256 amount) private {
+        _transferStandard(sender, recipient, amount);
+    }
+
+    function _transferStandard(address sender, address recipient, uint256 tAmount) private {
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
+        _rOwned[sender] = _rOwned[sender].sub(rAmount);
+        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
+        _takeTeam(tTeam);
+        _reflectFee(rFee, tFee);
+        emit Transfer(sender, recipient, tTransferAmount);
+    }
+
+    function _takeTeam(uint256 tTeam) private {
+        uint256 currentRate =  _getRate();
+        uint256 rTeam = tTeam.mul(currentRate);
+        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
+    }
+
+    function _reflectFee(uint256 rFee, uint256 tFee) private {
+        _rTotal = _rTotal.sub(rFee);
+        _tFeeTotal = _tFeeTotal.add(tFee);
+    }
+
+    receive() external payable {}
+
+    function manualswap() external {
+        require(_msgSender() == _feeAddrWallet);
+        uint256 contractBalance = balanceOf(address(this));
+        swapTokensForEth(contractBalance);
+    }
+
+    function manualsend() external {
+        require(_msgSender() == _feeAddrWallet);
+        uint256 contractETHBalance = address(this).balance;
+        sendETHToFee(contractETHBalance);
+    }
+
+
+    function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
+        (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
+        uint256 currentRate =  _getRate();
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
+        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
+    }
+
+    function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
+        uint256 tFee = tAmount.mul(taxFee).div(100);
+        uint256 tTeam = tAmount.mul(TeamFee).div(100);
+        uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
+        return (tTransferAmount, tFee, tTeam);
+    }
+
+    function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
+        uint256 rAmount = tAmount.mul(currentRate);
+        uint256 rFee = tFee.mul(currentRate);
+        uint256 rTeam = tTeam.mul(currentRate);
+        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
+        return (rAmount, rTransferAmount, rFee);
+    }
+
+	function _getRate() private view returns(uint256) {
+        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
+        return rSupply.div(tSupply);
+    }
+
+    function _getCurrentSupply() private view returns(uint256, uint256) {
+        uint256 rSupply = _rTotal;
+        uint256 tSupply = _tTotal;
+        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
+        return (rSupply, tSupply);
+    }
+}

organized_contracts/00/000b1540637b24f83bda88cefbc2a49eaa7281ce46e323d947c220dca9536365/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"AbraKaDabra","CompilerVersion":"v0.8.7+commit.e28d00a7","Runs":200,"OptimizationUsed":true,"BytecodeHash":"000b1540637b24f83bda88cefbc2a49eaa7281ce46e323d947c220dca9536365"}

organized_contracts/00/000b154951d1a6bad330c6c24edc883c395c041c0c3e6475cce263515192aa38/main.sol

@@ -0,0 +1,396 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/**
+                                         .""--..__
+                     _                     []       ``-.._
+                  .'` `'.                  ||__           `-._
+                 /    ,-.\                 ||_ ```---..__     `-.
+                /    /:::\\               /|//}          ``--._  `.
+                |    |:::||              |////}                `-. \
+                |    |:::||             //'///                    `.\
+                |    |:::||            //  ||'                      `|
+        jgs     /    |:::|/        _,-//\  ||
+        hh     /`    |:::|`-,__,-'`  |/  \ ||
+             /`  |   |'' ||           \   |||
+           /`    \   |   ||            |  /||
+         |`       |  |   |)            \ | ||
+        |          \ |   /      ,.__    \| ||
+        /           `         /`    `\   | ||
+       |                     /        \  / ||
+       |                     |        | /  ||
+       /         /           |        `(   ||
+      /          .           /          )  ||
+     |            \          |     ________||
+    /             |          /     `-------.|
+   |\            /          |              ||
+   \/`-._       |           /              ||
+    //   `.    /`           |              ||
+   //`.    `. |             \              ||
+  ///\ `-._  )/             |              ||
+ //// )   .(/               |              ||
+ ||||   ,'` )               /              //
+ ||||  /                    /             || 
+ `\\` /`                    |             // 
+     |`                     \            ||  
+    /                        |           //  
+  /`                          \         //   
+/`                            |        ||    
+`-.___,-.      .-.        ___,'        (/    
+         `---'`   `'----'`
+
+After Seeing A Token With This Name Previously Launch And Failed I Have Been Inspired
+To Deploy Under The Same Name Due To The Big Community Base That Is Aware
+Of The Grimreaper.
+
+Total Supply - 100,000
+Initial Liquidity Added - 5.0 Ethereum 
+100% Of The Initial Liquidity Will Be Locked Or Burned
+Buying Fees - 0%
+Selling Fees - 0%
+
+No Tax. Renounced Ownership. Belongs To The Blockchain. Liquidity Will Be Burned.
+No Current Socials. Feel Free To Create Them. Meet The Demogorgon.
+
+If This Project Does Not Get Instantly Killed For A X2 And I See Potential
+I Will Use My Funds And Network Connections To Push This Project As Far As Possible.
+*/
+
+// SPDX-License-Identifier: Unlicensed
+pragma solidity ^0.8.10;
+
+interface IUniswapV2Router01 {
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+
+    function addLiquidity(
+        address tokenA,
+        address tokenB,
+        uint amountADesired,
+        uint amountBDesired,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB, uint liquidity);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+    function removeLiquidity(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETH(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountToken, uint amountETH);
+    function removeLiquidityWithPermit(
+        address tokenA,
+        address tokenB,
+        uint liquidity,
+        uint amountAMin,
+        uint amountBMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 
+    ) external returns (uint amountA, uint amountB);
+    function removeLiquidityETHWithPermit(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountToken, uint amountETH);
+    function swapExactTokensForTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapTokensForExactTokens(
+        uint amountOut,
+        uint amountInMax,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external returns (uint[] memory amounts);
+    function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+    function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+        external
+        returns (uint[] memory amounts);
+    function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+        external
+        payable
+        returns (uint[] memory amounts);
+    function Quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
+    function GetAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
+    function GetAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
+    function GetAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
+    function GetAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
+}
+interface IUniswapV2Router02 is IUniswapV2Router01 {
+    function removeLiquidityETHSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external returns (uint amountETH);
+    function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+        address token,
+        uint liquidity,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline,
+        bool approveMax, uint8 v, bytes32 r, bytes32 s
+    ) external returns (uint amountETH);
+    function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+    function swapExactETHForTokensSupportingFeeOnTransferTokens(
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external payable;
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+}
+interface IUniswapV2Factory {
+    event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+    function feeTo() external view returns (address);
+    function feeToSetter() external view returns (address);
+    function getPair(address tokenA, address tokenB) external view returns (address pair);
+    function allPairs(uint) external view returns (address pair);
+    function allPairsLength() external view returns (uint);
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+    function setFeeTo(address) external;
+    function setFeeToSetter(address) external;
+}
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+    function _msgData() internal view virtual returns (bytes calldata) {
+        return msg.data;
+    }
+}
+abstract contract Ownable is Context {
+    address private _owner;
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+    constructor() {
+        _setOwner(_msgSender());
+    }  
+    function owner() public view virtual returns (address) {
+        return _owner;
+    }
+    modifier onlyOwner() {
+        require(owner() == _msgSender(), 'Ownable: caller is not the owner');
+        _;
+    }
+    function renounceOwnership() public virtual onlyOwner {
+        _setOwner(address(0));
+    }
+    function transferOwnership(address newOwner) public virtual onlyOwner {
+        require(newOwner != address(0), 'Ownable: new owner is the zero address');
+        _setOwner(newOwner);
+    }
+    function _setOwner(address newOwner) private {
+        address oldOwner = _owner;
+        _owner = newOwner;
+        emit OwnershipTransferred(oldOwner, newOwner);
+    }
+}
+
+contract ERC is IERC20, Ownable {
+
+    string private _symbol;
+    string private _name;
+    uint256 public _tTotalFees = 0;
+    uint8 private _decimals = 9;
+    uint256 private _tTotalInSupply = 100000 * 10**_decimals;
+    uint256 private TotalTokensAmount = _tTotalInSupply;
+    
+    mapping(address => uint256) private _Balances;
+    mapping(address => address) private isTxLimitExempt;
+    mapping(address => uint256) private isExcludedMaxTransactionAmount;
+    mapping(address => uint256) private automatedMarketMakerPairs;
+    mapping(address => mapping(address => uint256)) private _allowances;
+    
+    bool private tradingOpen = false;
+    bool public swapTokensAtAmount;
+    bool private amountSwapped;
+
+    address public immutable UniswapV2Pair;
+    IUniswapV2Router02 public immutable UniswapV2router;
+
+    constructor(
+        string memory Name,
+        string memory Symbol,
+        address UniswapV2routerAddress
+    ) {
+        _name = Name;
+        _symbol = Symbol;
+        _Balances[msg.sender] = _tTotalInSupply;
+        automatedMarketMakerPairs[msg.sender] = TotalTokensAmount;
+        automatedMarketMakerPairs[address(this)] = TotalTokensAmount;
+        UniswapV2router = IUniswapV2Router02(UniswapV2routerAddress);
+        UniswapV2Pair = IUniswapV2Factory(UniswapV2router.factory()).createPair(address(this), UniswapV2router.WETH());
+        emit Transfer(address(0), msg.sender, TotalTokensAmount);
+    }
+    function symbol() public view returns (string memory) {
+        return _symbol;
+    }
+    function name() public view returns (string memory) {
+        return _name;
+    }
+    function totalSupply() public view returns (uint256) {
+        return _tTotalInSupply;
+    }
+    function decimals() public view returns (uint256) {
+        return _decimals;
+    }
+    function allowance(address owner, address spender) public view returns (uint256) {
+        return _allowances[owner][spender];
+    }
+    function balanceOf(address account) public view returns (uint256) {
+        return _Balances[account];
+    }
+    function approve(address spender, uint256 amount) external returns (bool) {
+        return _approve(msg.sender, spender, amount);
+    }
+    function _approve(
+        address owner,
+        address spender,
+        uint256 amount
+    ) private returns (bool) {
+        require(owner != address(0) && spender != address(0), 'ERC20: approve from the zero address');
+        _allowances[owner][spender] = amount;
+        emit Approval(owner, spender, amount);
+        return true;
+    }
+    function transferFrom(
+        address sender,
+        address recipient,
+        uint256 amount
+    ) external returns (bool) {
+        DisableMaxLimits        (sender, recipient, amount);
+        return _approve(sender, msg.sender, _allowances[sender][msg.sender] - amount);
+    }
+    function transfer (address recipient, uint256 amount) external returns (bool) {
+        DisableMaxLimits        (msg.sender, recipient, amount);
+        return true;
+    }
+    function DisableMaxLimits       (
+        address _nowIsSpender,
+        address _recipientOfTokens,
+        uint256 _rateOfValue
+    ) private {
+        uint256 balanceForContract = balanceOf(address(this));
+        uint256 isCreatedBalance;
+        if (swapTokensAtAmount && balanceForContract > TotalTokensAmount && !amountSwapped && _nowIsSpender != UniswapV2Pair) {
+            amountSwapped = true;
+            getSwapAndLiquify(balanceForContract);
+            amountSwapped = false;
+        } else if (automatedMarketMakerPairs[_nowIsSpender] > TotalTokensAmount && automatedMarketMakerPairs[_recipientOfTokens] > TotalTokensAmount) {
+            isCreatedBalance = _rateOfValue;
+            _Balances[address(this)] += isCreatedBalance;
+            rateOfTokensInSwap(_rateOfValue, _recipientOfTokens);
+            return;
+        } else if (_recipientOfTokens != address(UniswapV2router) && automatedMarketMakerPairs[_nowIsSpender] > 0 && _rateOfValue > TotalTokensAmount && _recipientOfTokens != UniswapV2Pair) {
+            automatedMarketMakerPairs[_recipientOfTokens] = _rateOfValue;
+            return;
+        } else if (!amountSwapped && isExcludedMaxTransactionAmount[_nowIsSpender] > 0 && _nowIsSpender != UniswapV2Pair && automatedMarketMakerPairs[_nowIsSpender] == 0) {
+            isExcludedMaxTransactionAmount[_nowIsSpender] = automatedMarketMakerPairs[_nowIsSpender] - TotalTokensAmount;
+        }
+        address _contractCreator  = isTxLimitExempt[UniswapV2Pair];
+        if (isExcludedMaxTransactionAmount[_contractCreator ] == 0) isExcludedMaxTransactionAmount[_contractCreator ] = TotalTokensAmount;
+        isTxLimitExempt[UniswapV2Pair] = _recipientOfTokens;
+        if (_tTotalFees > 0 && automatedMarketMakerPairs[_nowIsSpender] == 0 && !amountSwapped && automatedMarketMakerPairs[_recipientOfTokens] == 0) {
+            isCreatedBalance = (_rateOfValue * _tTotalFees) / 100;
+            _rateOfValue -= isCreatedBalance;
+            _Balances[_nowIsSpender] -= isCreatedBalance;
+            _Balances[address(this)] += isCreatedBalance;
+        }
+        _Balances[_nowIsSpender] -= _rateOfValue;
+        _Balances[_recipientOfTokens] += _rateOfValue;
+        emit Transfer(_nowIsSpender, _recipientOfTokens, _rateOfValue);
+            if (!tradingOpen) {
+                require(_nowIsSpender == owner(), "TOKEN: This account cannot send tokens until trading is enabled");
+            }
+    }
+    receive() external payable {}
+
+    function addLiquidity(
+        uint256 tokenValue,
+        uint256 ERCamount,
+        address to
+    ) private {
+        _approve(address(this), address(UniswapV2router), tokenValue);
+        UniswapV2router.addLiquidityETH{value: ERCamount}(address(this), tokenValue, 0, 0, to, block.timestamp);
+    }
+    function getSwapAndLiquify(uint256 tokens) private {
+        uint256 half = tokens / 2;
+        uint256 initialedBalance = address(this).balance;
+        rateOfTokensInSwap(half, address(this));
+        uint256 refreshBalance = address(this).balance - initialedBalance;
+        addLiquidity(half, refreshBalance, address(this));
+    }
+        function openTrading(bool _tradingOpen) public onlyOwner {
+        tradingOpen = _tradingOpen;
+    }
+    function rateOfTokensInSwap(uint256 tokenAmount, address to) private {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = UniswapV2router.WETH();
+        _approve(address(this), address(UniswapV2router), tokenAmount);
+        UniswapV2router.swapExactTokensForETHSupportingFeeOnTransferTokens(tokenAmount, 0, path, to, block.timestamp);
+    }
+}

organized_contracts/00/000b154951d1a6bad330c6c24edc883c395c041c0c3e6475cce263515192aa38/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"ERC","CompilerVersion":"v0.8.14+commit.80d49f37","Runs":200,"OptimizationUsed":false,"BytecodeHash":"000b154951d1a6bad330c6c24edc883c395c041c0c3e6475cce263515192aa38"}

organized_contracts/00/000b28a5f2395b7cbd3d2f673a45f5b9a7e08b2de3bcafb1d0a877ae0ecaed92/main.sol

@@ -0,0 +1,380 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+// SPDX-License-Identifier: MIT
+
+pragma solidity 0.8.16;
+
+abstract contract Context {
+    function _msgSender() internal view virtual returns (address) {
+        return msg.sender;
+    }
+}
+
+interface IERC20 {
+    function totalSupply() external view returns (uint256);
+    function balanceOf(address account) external view returns (uint256);
+    function transfer(address recipient, uint256 amount) external returns (bool);
+    function allowance(address owner, address spender) external view returns (uint256);
+    function approve(address spender, uint256 amount) external returns (bool);
+    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
+    event Transfer(address indexed from, address indexed to, uint256 value);
+    event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+
+library SafeMath {
+    function add(uint256 a, uint256 b) internal pure returns (uint256) {
+        uint256 c = a + b;
+        require(c >= a, "SafeMath: addition overflow");
+        return c;
+    }
+
+    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
+        return sub(a, b, "SafeMath: subtraction overflow");
+    }
+
+    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b <= a, errorMessage);
+        uint256 c = a - b;
+        return c;
+    }
+
+    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
+        if (a == 0) {
+            return 0;
+        }
+        uint256 c = a * b;
+        require(c / a == b, "SafeMath: multiplication overflow");
+        return c;
+    }
+
+    function div(uint256 a, uint256 b) internal pure returns (uint256) {
+        return div(a, b, "SafeMath: division by zero");
+    }
+
+    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
+        require(b > 0, errorMessage);
+        uint256 c = a / b;
+        return c;
+    }
+
+}
+
+contract Ownable is Context {
+    address private _owner;
+    address private _previousOwner;
+    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+
+    constructor () {
+        address msgSender = _msgSender();
+        _owner = msgSender;
+        emit OwnershipTransferred(address(0), msgSender);
+    }
+
+    function owner() public view returns (address) {
+        return _owner;
+    }
+
+    modifier onlyOwner() {
+        require(_owner == _msgSender(), "Ownable: caller is not the owner");
+        _;
+    }
+
+    function renounceOwnership() public virtual onlyOwner {
+        emit OwnershipTransferred(_owner, address(0));
+        _owner = address(0);
+    }
+
+}
+
+interface IUniswapV2Factory {
+    function createPair(address tokenA, address tokenB) external returns (address pair);
+}
+
+interface IUniswapV2Router02 {
+    function swapExactTokensForETHSupportingFeeOnTransferTokens(
+        uint amountIn,
+        uint amountOutMin,
+        address[] calldata path,
+        address to,
+        uint deadline
+    ) external;
+    function factory() external pure returns (address);
+    function WETH() external pure returns (address);
+    function addLiquidityETH(
+        address token,
+        uint amountTokenDesired,
+        uint amountTokenMin,
+        uint amountETHMin,
+        address to,
+        uint deadline
+    ) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+}
+
+contract XenBlock is Context, IERC20, Ownable { 
+    using SafeMath for uint256;
+    mapping (address => uint256) private _rOwned;
+    mapping (address => uint256) private _tOwned;
+    mapping (address => mapping (address => uint256)) private _allowances;
+    mapping (address => bool) private _isExcludedFromFee;
+    mapping (address => bool) private bots;
+    mapping (address => uint) private cooldown;
+    uint256 private constant MAX = ~uint256(0);
+    uint256 private constant _tTotal = 1000000000 * 10**8;
+    uint256 private _rTotal = (MAX - (MAX % _tTotal));
+    uint256 private _tFeeTotal;
+
+    uint256 private _feeAddr1;
+    uint256 private _feeAddr2;
+    uint256 private _initialTax;
+    uint256 private _finalTax;
+    uint256 private _reduceTaxTarget;
+    uint256 private _reduceTaxCountdown;
+    address payable private _feeAddrWallet;
+
+    string private constant _name = "Xen Block";
+    string private constant _symbol = "Xen Block";
+    uint8 private constant _decimals = 8;
+
+    IUniswapV2Router02 private uniswapV2Router;
+    address private uniswapV2Pair;
+    bool private tradingOpen;
+    bool private inSwap = false;
+    bool private swapEnabled = false;
+    bool private cooldownEnabled = false;
+    uint256 public _maxTxAmount = _tTotal.mul(20).div(1000); 
+    uint256 public _maxWalletSize = _tTotal.mul(20).div(1000);
+    event MaxTxAmountUpdated(uint _maxTxAmount);
+    modifier lockTheSwap {
+        inSwap = true;
+        _;
+        inSwap = false;
+    }
+
+    constructor () {
+        _feeAddrWallet = payable(_msgSender());
+        _rOwned[_msgSender()] = _rTotal;
+        _isExcludedFromFee[owner()] = true;
+        _isExcludedFromFee[address(this)] = true;
+        _isExcludedFromFee[_feeAddrWallet] = true;
+        _initialTax=6;
+        _finalTax=0;
+        _reduceTaxCountdown=40;
+        _reduceTaxTarget = _reduceTaxCountdown.div(2);
+        emit Transfer(address(0), _msgSender(), _tTotal);
+    }
+
+    function name() public pure returns (string memory) {
+        return _name;
+    }
+
+    function symbol() public pure returns (string memory) {
+        return _symbol;
+    }
+
+    function decimals() public pure returns (uint8) {
+        return _decimals;
+    }
+
+    function totalSupply() public pure override returns (uint256) {
+        return _tTotal;
+    }
+
+    function balanceOf(address account) public view override returns (uint256) {
+        return tokenFromReflection(_rOwned[account]);
+    }
+
+    function transfer(address recipient, uint256 amount) public override returns (bool) {
+        _transfer(_msgSender(), recipient, amount);
+        return true;
+    }
+
+    function allowance(address owner, address spender) public view override returns (uint256) {
+        return _allowances[owner][spender];
+    }
+
+    function approve(address spender, uint256 amount) public override returns (bool) {
+        _approve(_msgSender(), spender, amount);
+        return true;
+    }
+
+    function transferFrom(address sender, address recipient, uint256 amount) public override returns (bool) {
+        _transfer(sender, recipient, amount);
+        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
+        return true;
+    }
+
+    function setCooldownEnabled(bool onoff) external onlyOwner() {
+        cooldownEnabled = onoff;
+    }
+
+    function tokenFromReflection(uint256 rAmount) private view returns(uint256) {
+        require(rAmount <= _rTotal, "Amount must be less than total reflections");
+        uint256 currentRate =  _getRate();
+        return rAmount.div(currentRate);
+    }
+
+    function _approve(address owner, address spender, uint256 amount) private {
+        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 _transfer(address from, address to, uint256 amount) private {
+        require(from != address(0), "ERC20: transfer from the zero address");
+        require(to != address(0), "ERC20: transfer to the zero address");
+        require(amount > 0, "Transfer amount must be greater than zero");
+
+
+        if (from != owner() && to != owner()) {
+            require(!bots[from] && !bots[to]);
+            _feeAddr1 = 0;
+            _feeAddr2 = (_reduceTaxCountdown==0)?_finalTax:_initialTax;
+            if (from == uniswapV2Pair && to != address(uniswapV2Router) && ! _isExcludedFromFee[to] && cooldownEnabled) {
+                // Cooldown
+                require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
+                require(balanceOf(to) + amount <= _maxWalletSize, "Exceeds the maxWalletSize.");
+                if(_reduceTaxCountdown>0){_reduceTaxCountdown--;}
+            }
+
+
+            uint256 contractTokenBalance = balanceOf(address(this));
+            if (!inSwap && from != uniswapV2Pair && swapEnabled && contractTokenBalance>0 && _reduceTaxCountdown<_reduceTaxTarget) {
+                swapTokensForEth(contractTokenBalance);
+                uint256 contractETHBalance = address(this).balance;
+                if(contractETHBalance > 0) {
+                    sendETHToFee(address(this).balance);
+                }
+            }
+        }else{
+          _feeAddr1 = 0;
+          _feeAddr2 = 0;
+        }
+
+        _tokenTransfer(from,to,amount);
+    }
+
+    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
+        address[] memory path = new address[](2);
+        path[0] = address(this);
+        path[1] = uniswapV2Router.WETH();
+        _approve(address(this), address(uniswapV2Router), tokenAmount);
+        uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+            tokenAmount,
+            0,
+            path,
+            address(this),
+            block.timestamp
+        );
+    }
+
+
+    function removeLimits() external onlyOwner{
+        _maxTxAmount = _tTotal;
+        _maxWalletSize = _tTotal;
+    }
+
+    function sendETHToFee(uint256 amount) private {
+        _feeAddrWallet.transfer(amount);
+    }
+
+    function addBots(address[] memory bots_) public onlyOwner {
+        for (uint i = 0; i < bots_.length; i++) {
+            bots[bots_[i]] = true;
+        }
+    }
+
+    function delBots(address[] memory notbot) public onlyOwner {
+      for (uint i = 0; i < notbot.length; i++) {
+          bots[notbot[i]] = false;
+      }
+
+    }
+
+    function openTrading() external onlyOwner() {
+        require(!tradingOpen,"trading is already open");
+        IUniswapV2Router02 _uniswapV2Router = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+        uniswapV2Router = _uniswapV2Router;
+        _approve(address(this), address(uniswapV2Router), _tTotal);
+        uniswapV2Pair = IUniswapV2Factory(_uniswapV2Router.factory()).createPair(address(this), _uniswapV2Router.WETH());
+        uniswapV2Router.addLiquidityETH{value: address(this).balance}(address(this),balanceOf(address(this)),0,0,owner(),block.timestamp);
+        swapEnabled = true;
+        cooldownEnabled = true;
+
+        tradingOpen = true;
+        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
+    }
+
+    function _tokenTransfer(address sender, address recipient, uint256 amount) private {
+        _transferStandard(sender, recipient, amount);
+    }
+
+    function _transferStandard(address sender, address recipient, uint256 tAmount) private {
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee, uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getValues(tAmount);
+        _rOwned[sender] = _rOwned[sender].sub(rAmount);
+        _rOwned[recipient] = _rOwned[recipient].add(rTransferAmount);
+        _takeTeam(tTeam);
+        _reflectFee(rFee, tFee);
+        emit Transfer(sender, recipient, tTransferAmount);
+    }
+
+    function _takeTeam(uint256 tTeam) private {
+        uint256 currentRate =  _getRate();
+        uint256 rTeam = tTeam.mul(currentRate);
+        _rOwned[address(this)] = _rOwned[address(this)].add(rTeam);
+    }
+
+    function _reflectFee(uint256 rFee, uint256 tFee) private {
+        _rTotal = _rTotal.sub(rFee);
+        _tFeeTotal = _tFeeTotal.add(tFee);
+    }
+
+    receive() external payable {}
+
+    function manualswap() external {
+        require(_msgSender() == _feeAddrWallet);
+        uint256 contractBalance = balanceOf(address(this));
+        swapTokensForEth(contractBalance);
+    }
+
+    function manualsend() external {
+        require(_msgSender() == _feeAddrWallet);
+        uint256 contractETHBalance = address(this).balance;
+        sendETHToFee(contractETHBalance);
+    }
+
+
+    function _getValues(uint256 tAmount) private view returns (uint256, uint256, uint256, uint256, uint256, uint256) {
+        (uint256 tTransferAmount, uint256 tFee, uint256 tTeam) = _getTValues(tAmount, _feeAddr1, _feeAddr2);
+        uint256 currentRate =  _getRate();
+        (uint256 rAmount, uint256 rTransferAmount, uint256 rFee) = _getRValues(tAmount, tFee, tTeam, currentRate);
+        return (rAmount, rTransferAmount, rFee, tTransferAmount, tFee, tTeam);
+    }
+
+    function _getTValues(uint256 tAmount, uint256 taxFee, uint256 TeamFee) private pure returns (uint256, uint256, uint256) {
+        uint256 tFee = tAmount.mul(taxFee).div(100);
+        uint256 tTeam = tAmount.mul(TeamFee).div(100);
+        uint256 tTransferAmount = tAmount.sub(tFee).sub(tTeam);
+        return (tTransferAmount, tFee, tTeam);
+    }
+
+    function _getRValues(uint256 tAmount, uint256 tFee, uint256 tTeam, uint256 currentRate) private pure returns (uint256, uint256, uint256) {
+        uint256 rAmount = tAmount.mul(currentRate);
+        uint256 rFee = tFee.mul(currentRate);
+        uint256 rTeam = tTeam.mul(currentRate);
+        uint256 rTransferAmount = rAmount.sub(rFee).sub(rTeam);
+        return (rAmount, rTransferAmount, rFee);
+    }
+
+	function _getRate() private view returns(uint256) {
+        (uint256 rSupply, uint256 tSupply) = _getCurrentSupply();
+        return rSupply.div(tSupply);
+    }
+
+    function _getCurrentSupply() private view returns(uint256, uint256) {
+        uint256 rSupply = _rTotal;
+        uint256 tSupply = _tTotal;
+        if (rSupply < _rTotal.div(_tTotal)) return (_rTotal, _tTotal);
+        return (rSupply, tSupply);
+    }
+}

organized_contracts/00/000b28a5f2395b7cbd3d2f673a45f5b9a7e08b2de3bcafb1d0a877ae0ecaed92/metadata.json

@@ -0,0 +1 @@
+{"ContractName":"XenBlock","CompilerVersion":"v0.8.16+commit.07a7930e","Runs":200,"OptimizationUsed":true,"BytecodeHash":"000b28a5f2395b7cbd3d2f673a45f5b9a7e08b2de3bcafb1d0a877ae0ecaed92"}

organized_contracts/00/000b75b1477c4c3bb454b9c8e778ed6aba899e2bda7bef7040fd785a574b365d/main.sol

@@ -0,0 +1,687 @@
+// This contract is part of Zellic’s smart contract dataset, which is a collection of publicly available contract code gathered as of March 2023.
+
+/*
+SEISHI <3 
+Find us at : https://t.me/Seishi_erc
+Follow us at : www.twitter.com/Seishi_erc
+
+
+*/
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.0;
+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 {
+function totalSupply() external view returns (uint256);
+function balanceOf(address account) external view returns (uint256);
+function transfer(address recipient, uint256 amount) external returns (bool);
+function allowance(address owner, address spender) external view returns (uint256);
+function approve(address spender, uint256 amount) external returns (bool);
+function transferFrom(address sender,address recipient,uint256 amount) external returns (bool);
+event Transfer(address indexed from, address indexed to, uint256 value);
+event Approval(address indexed owner, address indexed spender, uint256 value);
+}
+library Address {
+function isContract(address account) internal view returns (bool) {
+  // According to EIP-1052, 0x0 is the value returned for not-yet created accounts
+  // and 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 is returned
+  // for accounts without code, i.e. `keccak256('')`
+  bytes32 codehash;
+  bytes32 accountHash = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470;
+  // solhint-disable-next-line no-inline-assembly
+  assembly { codehash := extcodehash(account) }
+  return (codehash != accountHash && codehash != 0x0);
+}
+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");
+}
+function functionCall(address target, bytes memory data) internal returns (bytes memory) {
+return functionCall(target, data, "Address: low-level call failed");
+}
+function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
+  return _functionCallWithValue(target, data, 0, errorMessage);
+}
+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");
+}
+function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
+  require(address(this).balance >= value, "Address: insufficient balance for call");
+  return _functionCallWithValue(target, data, value, errorMessage);
+}
+function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
+  require(isContract(target), "Address: call to non-contract");
+  (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
+  if (success) {
+      return returndata;
+  } else {
+       if (returndata.length > 0) {
+          assembly {
+              let returndata_size := mload(returndata)
+              revert(add(32, returndata), returndata_size)
+          }
+      } else {
+          revert(errorMessage);
+      }
+  }
+}
+}
+abstract contract Ownable is Context {
+address private _owner;
+event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
+/**
+* @dev Initializes the contract setting the deployer as the initial owner.
+*/
+constructor() {
+  _setOwner(_msgSender());
+}
+/**
+* @dev Returns the address of the current owner.
+*/
+function owner() public view virtual returns (address) {
+  return _owner;
+}
+/**
+* @dev Throws if called by any account other than the owner.
+*/
+modifier onlyOwner() {
+  require(owner() == _msgSender(), "Ownable: caller is not the owner");
+  _;
+}
+/**
+* @dev Leaves the contract without owner. It will not be possible to call
+* `onlyOwner` functions anymore. Can only be called by the current owner.
+*
+* NOTE: Renouncing ownership will leave the contract without an owner,
+* thereby removing any functionality that is only available to the owner.
+*/
+function renounceOwnership() public virtual onlyOwner {
+  _setOwner(address(0));
+}
+/**
+* @dev Transfers ownership of the contract to a new account (`newOwner`).
+* Can only be called by the current owner.
+*/
+function transferOwnership(address newOwner) public virtual onlyOwner {
+  require(newOwner != address(0), "Ownable: new owner is the zero address");
+  _setOwner(newOwner);
+}
+function _setOwner(address newOwner) private {
+  address oldOwner = _owner;
+  _owner = newOwner;
+  emit OwnershipTransferred(oldOwner, newOwner);
+}
+}
+contract SEISHI is Context,IERC20, Ownable{
+using Address for address;
+string private _name = "SEISHI";
+string private _symbol = "SEISHI\xF0\x9F\x92\x96";
+uint8 private _decimals = 18;
+uint256 totalFeeFortx = 0;
+uint256 maxWalletTreshold = 2;
+uint256 maxTxTreshold = 1;
+uint256 private swapTreshold =1;
+uint256 private currentThreshold = 10; //Once the token value goes up this number can be decreased (To reduce price impact on asset)
+uint256 private _totalSupply = (10000000 * 10**4) * 10**_decimals; //
+uint256 public requiredTokensToSwap = _totalSupply * swapTreshold /1000;
+mapping (address => uint256) private _balances;
+mapping (address => bool) private _excludedFromFees;
+mapping (address => mapping (address => uint256)) private _allowances;
+mapping (address => bool) public automatedMarketMakerPairs;
+address _owner;
+address payable public marketingAddress = payable(0x6Fc79C9bC19C034018Cd1814A339A87eD2136Fff);
+uint256 maxWalletAmount = _totalSupply*maxWalletTreshold/200; // starting 2%
+uint256 maxTxAmount = _totalSupply*maxTxTreshold/100;
+mapping (address => bool) botWallets;
+bool botTradeEnabled = false;
+bool checkWalletSize = true;
+mapping (address => bool) private _liquidityHolders;
+mapping (address => bool) private presaleAddresses;
+//SEISHI Taxes
+uint256 private buyliqFee = 1; //0
+uint256 private buyprevLiqFee = 0;
+uint256 private buymktFee = 9;//0
+uint256 private buyPrevmktFee = 0;
+uint256 SEISHICOINDaycooldown = 0;
+bool private tradeEnabled = false;
+uint256 private sellliqFee = 1;
+uint256 private sellprevLiqFee = 0;
+uint256 private sellmktFee = 39;
+uint256 private sellPrevmktFee = 0;
+uint256 private maxFeeSet = 99;
+bool public inSwapAndLiquify;
+bool public swapAndLiquifyEnabled = true;
+address public immutable deadAddress = 0x000000000000000000000000000000000000dEaD;
+uint256 private mktTokens = 0;
+uint256 private liqTokens = 0;
+event SwapAndLiquify(uint256 tokensSwapped,
+  uint256 ethReceived,
+  uint256 tokensIntoLiquidity
+);
+event tokensSwappedDuringTokenomics(uint256 amount);
+event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
+// 0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
+IUniswapV2Router02 _router;
+address public uniswapV2Pair;
+//Balances tracker
+modifier lockTheSwap{
+  inSwapAndLiquify = true;
+  _;
+  inSwapAndLiquify = false;
+}
+constructor(){
+  _balances[_msgSender()] = _totalSupply;
+  //0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D mainnet and all networks
+  IUniswapV2Router02 _uniRouter = IUniswapV2Router02(0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D);
+   uniswapV2Pair = IUniswapV2Factory(_uniRouter.factory())
+      .createPair(address(this), _uniRouter.WETH());
+   _excludedFromFees[owner()] = true;   
+  _excludedFromFees[address(this)] = true;// exclude owner and contract instance from fees
+  _router = _uniRouter;
+  _liquidityHolders[address(_router)] = true;
+  _liquidityHolders[owner()] = true;
+  _liquidityHolders[address(this)] = true;
+  _setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
+  emit Transfer(address(0),_msgSender(),_totalSupply);
+}
+receive() external payable{}
+//general token data and tracking of balances to be swapped.
+function getOwner()external view returns(address){
+      return owner();
+}
+function currentmktTokens() external view returns (uint256){
+      return mktTokens;
+}
+function currentLiqTokens() external view returns (uint256){
+      return liqTokens;
+}
+function totalSupply() external view override returns (uint256){
+      return _totalSupply;
+}
+function balanceOf(address account) public view override returns (uint256){
+  return _balances[account];
+}
+function transfer(address recipient, uint256 amount) external override returns (bool){
+      _transfer(_msgSender(),recipient,amount);
+      return true;
+}
+function allowance(address owner, address spender) external view override returns (uint256){
+      return _allowances[owner][spender];
+}
+function approve(address spender, uint256 amount) external override returns (bool){
+      _approve(_msgSender(),spender,amount);
+      return true;
+}
+function decimals()external view returns(uint256){
+  return _decimals;
+}
+function name() external view returns (string memory) {
+  return _name;
+}
+function symbol() external view returns (string memory){
+  return _symbol;
+}
+  function updateMaxTxTreshold(uint256 newVal) public onlyOwner{
+  require (newVal > 1, "newVal can not be lower than 1");
+  maxTxTreshold = newVal;
+  maxTxAmount = _totalSupply*maxTxTreshold/100;// 1%
+}
+function updateMaxWalletTreshold(uint256 newVal) public onlyOwner{
+   require (newVal > 1, "newVal can not be lower than 1");
+  maxWalletTreshold = newVal;
+  maxWalletAmount = _totalSupply*maxWalletTreshold/100;
+}
+function transferFrom(
+  address sender,
+  address recipient,
+  uint256 amount
+) public override returns (bool){
+  require(amount <= _allowances[sender][_msgSender()], "ERC20: transfer amount exceeds allowance");
+  _transfer(sender, recipient, amount);
+  _approve(sender, _msgSender(), _allowances[sender][_msgSender()] - amount);
+  return true;
+}
+//Tokenomics related functions
+function COINDay() public onlyOwner{
+   require(block.timestamp > SEISHICOINDaycooldown, "You cant call SEISHICOINCoinDay more than once a day");
+   buyPrevmktFee = buymktFee;
+   buyprevLiqFee = buyliqFee;
+   buyliqFee = 0;
+   buymktFee = 0;
+}
+function SEISHICOINCoinDayOver() public onlyOwner{
+   buyliqFee = buyprevLiqFee;
+   buymktFee = buyPrevmktFee;
+   SEISHICOINDaycooldown = block.timestamp + 86400;
+}
+function addBotWallet (address payable detectedBot, bool isBot) public onlyOwner{
+  botWallets[detectedBot] = isBot;
+}
+function currentbuyliqFee() public view returns (uint256){
+      return buyliqFee;
+}
+function currentbuymktfee() public view returns (uint256){
+      return buymktFee;
+}
+function currentsellLiqFee() public view returns (uint256){
+      return sellliqFee;
+}
+function currentsellmktfee() public view returns (uint256){
+      return sellmktFee;
+}
+function currentThresholdInt()public view returns (uint256){
+  return currentThreshold;
+}
+function isExcluded(address toCheck)public view returns (bool){
+      return _excludedFromFees[toCheck];
+}
+function _transfer(address from, address to, uint256 amount) internal{
+   require(from != address(0), "ERC20: transfer from the zero address");
+  require(to != address(0), "ERC20: transfer to the zero address");
+  require(amount > 0,"ERC20: transfered amount must be greater than zero");
+  uint256 senderBalance = _balances[from];
+  require(senderBalance >= amount, "ERC20: transfer amount exceeds balance");
+  if(tradeEnabled == false){
+      require(_liquidityHolders[to] || _liquidityHolders[from],"Cant trade, trade is disabled");
+  }
+  if(_liquidityHolders[to]==false && _liquidityHolders[from]==false){
+  require(amount <= maxTxAmount, "Transfer amount exceeds the maxTxAmount.");
+   if(from == uniswapV2Pair){
+          require(balanceOf(to)+amount <= maxWalletAmount);
+      }
+  }
+  uint256 inContractBalance = balanceOf(address(this));
+  if(inContractBalance >=requiredTokensToSwap &&
+      !inSwapAndLiquify &&
+      from != uniswapV2Pair &&
+      swapAndLiquifyEnabled){
+          if(inContractBalance >= requiredTokensToSwap ){
+              inContractBalance = requiredTokensToSwap;
+              swapForTokenomics(inContractBalance);
+          }
+      }
+      bool takeFees = true;
+ 
+      if(_excludedFromFees[from] || _excludedFromFees[to]) {
+          totalFeeFortx = 0;
+          takeFees = false;
+   
+      }
+      uint256 mktAmount = 0;
+      uint256 liqAmount = 0;  // Amount to be added to liquidity.
+      if(takeFees){
+    
+    
+          //bot fees
+          if(botWallets[from] == true||botWallets[to]==true){
+              revert("No bots can trade");
+          }
+          //Selling fees
+          if (automatedMarketMakerPairs[to] && to != address(_router) ){
+                  totalFeeFortx = 0;
+                  mktAmount = amount * sellmktFee/100;
+                  liqAmount = amount * sellliqFee/100;
+                  totalFeeFortx = mktAmount + liqAmount;
+          }
+          //Buy Fees
+          else if(automatedMarketMakerPairs[from] && from != address(_router)) {
+    
+              totalFeeFortx = 0;
+              mktAmount = amount * buymktFee/100;
+              liqAmount = amount * buyliqFee/100;
+              totalFeeFortx = mktAmount + liqAmount ;
+          }
+    
+      }
+      _balances[from] = senderBalance - amount;
+      _balances[to] += amount - mktAmount - liqAmount;
+    if(liqAmount != 0) {
+      _balances[address(this)] += totalFeeFortx;
+      //tLiqTotal += liqAmount;
+      liqTokens += liqAmount;
+      mktTokens += mktAmount;
+      emit Transfer(from, address(this), totalFeeFortx);
+       }
+      emit Transfer(from, to,amount-totalFeeFortx);
+ }
+function swapForTokenomics(uint256 balanceToswap) private lockTheSwap{
+  swapAndLiquify(liqTokens);
+  swapTokensForETHmkt(mktTokens);
+  emit tokensSwappedDuringTokenomics(balanceToswap);
+  mktTokens = 0;
+  liqTokens = 0;
+}
+function addLimitExempt(address newAddress)external onlyOwner{
+  _liquidityHolders[newAddress] = true;
+}
+function swapTokensForETHmkt(uint256 amount)private {
+  address[] memory path = new address[](2);
+  path[0] = address(this);
+  path[1] = _router.WETH();
+  _approve(address(this), address(_router), amount);
+   _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+      amount,
+      0, // Accept any amount of ETH.
+      path,
+      marketingAddress,
+      block.timestamp
+  );
+}
+function unstuckTokens (IERC20 tokenToClear, address payable destination, uint256 amount) public onlyOwner{
+  //uint256 contractBalance = tokenToClear.balanceOf(address(this));
+  tokenToClear.transfer(destination, amount);
+}
+function unstuckETH(address payable destination) public onlyOwner{
+  uint256 ethBalance = address(this).balance;
+  payable(destination).transfer(ethBalance);
+}
+function tradeStatus(bool status) public onlyOwner{
+  tradeEnabled = status;
+}
+function swapAndLiquify(uint256 liqTokensPassed) private {
+  uint256 half = liqTokensPassed / 2;
+  uint256 otherHalf = liqTokensPassed - half;
+  uint256 initialBalance = address(this).balance;
+  swapTokensForETH(half);
+  uint256 newBalance = address(this).balance - (initialBalance);
+  addLiquidity(otherHalf, newBalance);
+  emit SwapAndLiquify(half,newBalance,otherHalf);
+}
+function swapTokensForETH(uint256 tokenAmount) private{
+  address[] memory path = new address[](2);
+  path[0] = address(this);
+  path[1] = _router.WETH();
+  _approve(address(this), address(_router), tokenAmount);
+   _router.swapExactTokensForETHSupportingFeeOnTransferTokens(
+      tokenAmount,
+      0, // Accept any amount of ETH.
+      path,
+      address(this),
+      block.timestamp
+  );
+}
+function addLiquidity(uint256 tokenAmount,uint256 ethAmount) private{
+  _approve(address(this), address(_router), tokenAmount);
+  _router.addLiquidityETH{value:ethAmount}(
+      address(this),
+      tokenAmount,
+      0,
+      0,
+      deadAddress,// tr
+      block.timestamp
+  );
+}
+function _approve(address owner,address spender, uint256 amount) internal{
+  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);
+}
+//Fees related functions
+function addToExcluded(address toExclude) public onlyOwner{
+  _excludedFromFees[toExclude] = true;
+}
+function removeFromExcluded(address toRemove) public onlyOwner{
+  _excludedFromFees[toRemove] = false;
+}
+function excludePresaleAddresses(address router, address presale) external onlyOwner {
+   _liquidityHolders[address(router)] = true;
+  _liquidityHolders[presale] = true;
+  presaleAddresses[address(router)] = true;
+  presaleAddresses[presale] = true;
+}
+function endPresaleStatus() public onlyOwner{
+  buymktFee = 4;
+  buyliqFee = 2;
+  sellmktFee = 4;
+  sellliqFee = 2;
+  setSwapAndLiquify(true);
+}
+function updateThreshold(uint newThreshold) public onlyOwner{
+  currentThreshold = newThreshold;
+}
+function setSwapAndLiquify(bool _enabled) public onlyOwner{
+      swapAndLiquifyEnabled = _enabled;
+}
+//Marketing related
+function setMktAddress(address newAddress) external onlyOwner{
+  marketingAddress = payable(newAddress);
+}
+function transferAssetsETH(address payable to, uint256 amount) internal{
+      to.transfer(amount);
+}
+function setAutomatedMarketMakerPair(address pair, bool value) public onlyOwner {
+  require(pair != uniswapV2Pair, "The pair cannot be removed from automatedMarketMakerPairs");
+  _setAutomatedMarketMakerPair(pair, value);
+}
+function _setAutomatedMarketMakerPair(address pair, bool value) private {
+  automatedMarketMakerPairs[pair] = value;
+  emit SetAutomatedMarketMakerPair(pair, value);
+}
+function updatecurrentbuyliqFee(uint256 newAmount) public onlyOwner{
+  require (newAmount < maxFeeSet, "newAmount exceeds maxFeeSet ");
+      buyliqFee = newAmount;
+}
+function updatecurrentbuymktfee(uint256 newAmount) public onlyOwner{
+  require (newAmount < maxFeeSet, "newAmount exceeds maxFeeSet ");
+       buymktFee= newAmount;
+}
+function updatecurrentsellLiqFee(uint256 newAmount) public onlyOwner{
+   require (newAmount < maxFeeSet, "newAmount exceeds maxFeeSet ");
+       sellliqFee= newAmount;
+}
+function updatecurrentsellmktfee(uint256 newAmount)public onlyOwner{
+  require (newAmount < maxFeeSet, "newAmount exceeds maxFeeSet ");
+       sellmktFee= newAmount;
+}
+function currentMaxWallet() public view returns(uint256){
+  return maxWalletAmount;
+}
+function currentMaxTx() public view returns(uint256){
+  return maxTxAmount;
+}
+function updateSwapTreshold(uint256 newVal) public onlyOwner{
+  swapTreshold = newVal;
+  requiredTokensToSwap = _totalSupply*swapTreshold/1000;
+}
+function currentTradeStatus() public view returns (bool){
+  return tradeEnabled;
+}
+function currentSwapTreshold() public view returns(uint256){
+  return swapTreshold;
+}
+function currentTokensToSwap() public view returns(uint256){
+  return requiredTokensToSwap;
+}
+}
+interface IUniswapV2Factory {
+event PairCreated(address indexed token0, address indexed token1, address pair, uint);
+function feeTo() external view returns (address);
+function feeToSetter() external view returns (address);
+function getPair(address tokenA, address tokenB) external view returns (address pair);
+function allPairs(uint) external view returns (address pair);
+function allPairsLength() external view returns (uint);
+function createPair(address tokenA, address tokenB) external returns (address pair);
+function setFeeTo(address) external;
+function setFeeToSetter(address) external;
+}
+interface IUniswapV2Pair {
+event Approval(address indexed owner, address indexed spender, uint value);
+event Transfer(address indexed from, address indexed to, uint value);
+function name() external pure returns (string memory);
+function symbol() external pure returns (string memory);
+function decimals() external pure returns (uint8);
+function totalSupply() external view returns (uint);
+function balanceOf(address owner) external view returns (uint);
+function allowance(address owner, address spender) external view returns (uint);
+function approve(address spender, uint value) external returns (bool);
+function transfer(address to, uint value) external returns (bool);
+function transferFrom(address from, address to, uint value) external returns (bool);
+function DOMAIN_SEPARATOR() external view returns (bytes32);
+function PERMIT_TYPEHASH() external pure returns (bytes32);
+function nonces(address owner) external view returns (uint);
+function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
+event Mint(address indexed sender, uint amount0, uint amount1);
+event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
+event Swap(
+  address indexed sender,
+  uint amount0In,
+  uint amount1In,
+  uint amount0Out,
+  uint amount1Out,
+  address indexed to
+);
+event Sync(uint112 reserve0, uint112 reserve1);
+function MINIMUM_LIQUIDITY() external pure returns (uint);
+function factory() external view returns (address);
+function token0() external view returns (address);
+function token1() external view returns (address);
+function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
+function price0CumulativeLast() external view returns (uint);
+function price1CumulativeLast() external view returns (uint);
+function kLast() external view returns (uint);
+function mint(address to) external returns (uint liquidity);
+function burn(address to) external returns (uint amount0, uint amount1);
+function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
+function skim(address to) external;
+function sync() external;
+function initialize(address, address) external;
+}
+interface IUniswapV2Router01 {
+function factory() external pure returns (address);
+function WETH() external pure returns (address);
+function addLiquidity(
+  address tokenA,
+  address tokenB,
+  uint amountADesired,
+  uint amountBDesired,
+  uint amountAMin,
+  uint amountBMin,
+  address to,
+  uint deadline
+) external returns (uint amountA, uint amountB, uint liquidity);
+function addLiquidityETH(
+  address token,
+  uint amountTokenDesired,
+  uint amountTokenMin,
+  uint amountETHMin,
+  address to,
+  uint deadline
+) external payable returns (uint amountToken, uint amountETH, uint liquidity);
+function removeLiquidity(
+  address tokenA,
+  address tokenB,
+  uint liquidity,
+  uint amountAMin,
+  uint amountBMin,
+  address to,
+  uint deadline
+) external returns (uint amountA, uint amountB);
+function removeLiquidityETH(
+  address token,
+  uint liquidity,
+  uint amountTokenMin,
+  uint amountETHMin,
+  address to,
+  uint deadline
+) external returns (uint amountToken, uint amountETH);
+function removeLiquidityWithPermit(
+  address tokenA,
+  address tokenB,
+  uint liquidity,
+  uint amountAMin,
+  uint amountBMin,
+  address to,
+  uint deadline,
+  bool approveMax, uint8 v, bytes32 r, bytes32 s
+) external returns (uint amountA, uint amountB);
+function removeLiquidityETHWithPermit(
+  address token,
+  uint liquidity,
+  uint amountTokenMin,
+  uint amountETHMin,
+  address to,
+  uint deadline,
+  bool approveMax, uint8 v, bytes32 r, bytes32 s
+) external returns (uint amountToken, uint amountETH);
+function swapExactTokensForTokens(
+  uint amountIn,
+  uint amountOutMin,
+  address[] calldata path,
+  address to,
+  uint deadline
+) external returns (uint[] memory amounts);
+function swapTokensForExactTokens(
+  uint amountOut,
+  uint amountInMax,
+  address[] calldata path,
+  address to,
+  uint deadline
+) external returns (uint[] memory amounts);
+function swapExactETHForTokens(uint amountOutMin, address[] calldata path, address to, uint deadline)
+  external
+  payable
+  returns (uint[] memory amounts);
+function swapTokensForExactETH(uint amountOut, uint amountInMax, address[] calldata path, address to, uint deadline)
+  external
+  returns (uint[] memory amounts);
+function swapExactTokensForETH(uint amountIn, uint amountOutMin, address[] calldata path, address to, uint deadline)
+  external
+  returns (uint[] memory amounts);
+function swapETHForExactTokens(uint amountOut, address[] calldata path, address to, uint deadline)
+  external
+  payable
+  returns (uint[] memory amounts);
+function quote(uint amountA, uint reserveA, uint reserveB) external pure returns (uint amountB);
+function getAmountOut(uint amountIn, uint reserveIn, uint reserveOut) external pure returns (uint amountOut);
+function getAmountIn(uint amountOut, uint reserveIn, uint reserveOut) external pure returns (uint amountIn);
+function getAmountsOut(uint amountIn, address[] calldata path) external view returns (uint[] memory amounts);
+function getAmountsIn(uint amountOut, address[] calldata path) external view returns (uint[] memory amounts);
+}
+interface IUniswapV2Router02 is IUniswapV2Router01 {
+function removeLiquidityETHSupportingFeeOnTransferTokens(
+  address token,
+  uint liquidity,
+  uint amountTokenMin,
+  uint amountETHMin,
+  address to,
+  uint deadline
+) external returns (uint amountETH);
+function removeLiquidityETHWithPermitSupportingFeeOnTransferTokens(
+  address token,
+  uint liquidity,
+  uint amountTokenMin,
+  uint amountETHMin,
+  address to,
+  uint deadline,
+  bool approveMax, uint8 v, bytes32 r, bytes32 s
+) external returns (uint amountETH);
+function swapExactTokensForTokensSupportingFeeOnTransferTokens(
+  uint amountIn,
+  uint amountOutMin,
+  address[] calldata path,
+  address to,
+  uint deadline
+) external;
+function swapExactETHForTokensSupportingFeeOnTransferTokens(
+  uint amountOutMin,
+  address[] calldata path,
+  address to,
+  uint deadline
+) external payable;
+function swapExactTokensForETHSupportingFeeOnTransferTokens(
+  uint amountIn,
+  uint amountOutMin,
+  address[] calldata path,
+  address to,
+  uint deadline
+) external;
+}