creation_sourcecode: {{
    "language": "Solidity",
    "sources": {
      "contracts/ACT.sol": {
        "content": "// SPDX-License-Identifier: MIT\n\npragma solidity ^0.8.0;\n\n/// @title: AUCTIONS\n/// @author: manifold.xyz\n\nimport \"./manifold/ERC721Creator.sol\";\n\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n//                                                                                                            //\n//                                                                                                            //\n//     .!                         .dHZZWSXKSuXuXwrrrtttttttttOtrwvzwvh_:(11U.                      ,b,`_??    //\n//                             .dHyXXkXkXHVU0rrrrOtOtrOtllll==llOrvOzXh~(+z??h,                     O4w=.`    //\n//                           .HWWXWHHHMMHUXwrrtttttlll=zOwz==zlrOvz<+zOh_~.1?zWk,                      7.?    //\n//         `   `   `   `  `.HXXWWWWWWWU0ttttlllt====?===zztZwOtv<<<<<+Orh(<(O=??WS,  `   `   `           H    //\n//                        JWSXXWUXXWUOtllwl===?zOzz1zlz111<<;<CO+_::<1zwwWJ++tOIlTkh,           `             //\n//    Jh        .Xn     .UrwXUwwXXXOl===zV==??1zttOOz+<<:::::~~:?zO+<<>vXyUe+lvzwwrWkh.            `          //\n//    W4|   `   .v?h   JOOwUOOwXZSI===ztw0rttvz<>1=<1z<:~:~~~::~:(?ZXwz=lZWUNAywOVOOtWW&   `           .J^    //\n//    kd$       .l vL.0lOX0lzzX0XI=ttltOOZ<<;;::::<<<<zz<~::::::<>+zOZXXwwUZwXHXOOOTCzOWH,    `     .(v!      //\n//    I$X       .f=zdD1wZOlzwwXOVzz<<<<:<I<:~~:~~:~~<+(<1x(<;++>><<+1wWStttttZZXWwzvwZVrdZh.    ..zy=`        //\n//    Z((.   `  .R{1D+wVll1rvwZzI::~~:~~_j<~~~~~:~~~~~<11zw+:<+1Ozz+<(<1vUXAyOdyZWXuwwswrKwd&xUGv\"`           //\n//    j.W;      .Rvd<OIv11v1rOIj>~~~~~~~~(z_~~:_~:~_~_~<1zOwy+:<>+1OOwwO++1zttZVUUUUUUUUOlueZW/               //\n//    ?,JL.     .Xd$+Z<;1v<jIzI(<~~~_(_~~(I+_:_(<~:<<_~~_<?OwXO+<>???zzOOZVXXwAwAwAAwXUW8Oz===vi              //\n//    +J,b?     JOX:J~<(v<_zzt1(z~:~(<<~:(j??<(<:;<;<<1<_~~~<vUAO+??==llllltZXXOrruwQWSZl=OOlz=z4,            //\n//    .74P      KZD(>(~+>~(z?dX(1<(((1?z::<I<1+(<:;><><<1zz+<<;<zVOz??==zlllllZwXQWSXVl=====zOOlzwo           //\n//    (Vj\\   ` .KXlc<<(v__(=zw>I+z(>_1zz<:(z1<1z<<<<<1z=1++zOOz+????zz1zzzzAZz??vwvzXz?<+??????zIytS,  `      //\n//    ' J}     .XX(?><+<<;jOz$>j+z<+<+z1O<:+kz<?1z=+<1?zz=z&+v7TI=z1=OOOz1<<?<?>>+Vyrrtz+<<<<<>>;<+7Ok,       //\n//     JC`     JwUI?????>>ztd>>>O1O+=+t?zO<~j4c+<<1Oz&vXZZC+;<<-_(<?<++<;:<+<;;;>>;<vA7=jwOz+<_:<<:;:<<71-    //\n//    Pm]   `  H0X===???>>zOZ>><<GzOzzzz?zO+(r?n+&zzvUZz?Ozz1z-_~<?i+zOOOz_:<1+<;;;;>>z-,kwrvrwOz++(((;::_    //\n//    Wv`     .Sv$ll?>>z>;zID><~~<Z1Ol=Oz+zO+(-~?&1zz<<11+?1zzlv77!~`__1v1?1+_~?1z+<;>>>?UwwwwzvvzzwwOlzz+    //\n//    `    `  ,Kd?zv>+?z;;1l$><~~~<I1lllO>+=zzI~~_?i?O+<<<+1~........`.-(Ox<<?1+-~?zOz+>>>+4x11zCOUUVXvZOT    //\n//             J$?zz;+?z;:+zI<((J+z10v3ltz>+?=zl.~~~_<~<<_..._-<2-.>(v(Jo(J9z+_~?1+_<zOOOzz?>vGx>>>>>>?>??    //\n//            .?<?tz;1>=<(jd9C<<~~~~~1+1Olz>>??v/..~.~..__(<((ndkQMMMM@7j{ ~.?Oz-_(1Oz+llzOOzz+>?I&+>?>+zv    //\n//       `    ` (?lz;=<+<:(zz<~~~~~~~~(z<zOz>>><v/~~.~_(<~(mMMMMMndHW+,`.>_(C> (71z++=zOrtOzz1zzzz+1TGxv>>    //\n//         .>   (?zz>=<+z_(zI<~~~:~~~~~~1+?tz>>;;?/.~._~wWM7UfVWY4MUXY% -_(6>```_`(?Twzz?1zOtOttzzzzCCO+ZV    //\n//      ` ,1<(._(?=z<z<<=<~+I<~~~~~:~~:~~_1(1z+;;;?/.~_jW9~_ .Q0UVOOZ'.(<jS'``````_~_(kUkzz====1zllOOOlz1+    //\n//      .0?>u1j;-+1z+z<(1z_($<~~:(((?<<><<~_1-1z<::?+..(!. ````_77zj<!~-OY~`.`....`..WZXXXuXUXA&zz==??????    //\n//     ,I=1/+j$;<?=z+lc~<O<_Z<jzJAgdKkmQgJ.~~~?+<~_:(1~......_!?<~_.~(CJ>.`.`.` mJJWZuuwrOzOrwwOttOVUUXkUU    //\n//    Zl=u^.j!I;<=?=?lI:~jz:WwkWM9MM@@3dM\"7~~~~~~<--_<O-..........~(C<J~````.`..wXXkkkQQkUUC<>;<<<1wgHSuuX    //\n//    l=v'.z\\.<;>=???1z_~(UUMWkD~`!.NYOMSL<_~~.~.~.~_<1v&_..~.~._(<~(>_`.```...(Omylltlttlll==1- ?CUUXkzzw    //\n//    l2  ,> ,;;>=>?=?d2::?Gd@Ux<``7XVC++Z'..~....~...._?vu,.~(J>~(C~_.``..``.(>>Jy+7WkQQkWWHHSx-(zzvrrZVW    //\n//    =  .z  ,:<;=?+Ozww<::?0WrdRI.`  _(+<_.~.. .~.~.~....~_?7<<?<~.~~`.`.`..(3>>>?S<;dNkbbpVZZuuuzzvvrrrt    //\n//       ,\\  .<c:+?>ZzdrI;<:(4kyrh(?v<>~...~~.~.~.~.~.~~.....~.~.~~..~.```..(3;;;;~.?o;MkbpfVyZZXXuzvvrrrr    //\n//       J   .cZ:<<;tzdwwc<1::?w4wh((,...~..~.~~.~.~.~~.~~~~~.~~.~.~..`.. -J3>;;;;_.. _HkbpfVyyZG&wuuzzvrr    //\n//       %    3d-:~:jzdwwZ++<1-_?O<J^<<~?u_....~..~~.~.~~.~.~-~~~.~......(Y>>;;;;:_....HbbppfVyyZZZZuuuzzr    //\n//       (    ,zz~<_(1(ZZXyzz(:?1+-z<++<~.1_....~.~.~~~.~(-?<~~.~~.~.._(J>>;;;;;;<_...JbbbbbbpffVVyyyZZuuz    //\n//    /7<?7~...1II(-~(>I?c7zOwv+_?1/~......1-.....(Y77<?<~~~~~.~~.~~._JC;;;;>;;;<~...(NkkkkkbppppfffffVXXu    //\n//    ...!~`..(>?>1+-.1j<J1+;<COJ?<?7!..._i.1-.`......_~~~~~..~~.~.~J3;;;;>>;;;<~...(HbbbkkkkkkbbbbbpfVVyX    //\n//    `.`..`.=<<<(<?zc-1I+JOI++++;?Y+.`....z~h_.```....__~......~~(s;;;;;;>;;;<~~..(Hbbppbbkkkkkkkbbbpffff    //\n//    .<~`..C:::::::;;<;?Gx1++;>;>;;;?&<(~~(l/2C(..```..........(WK?4+;;>>;;<~~~..(NpfpffppbbbbkkbbWbbppbp    //\n//    .`.._r~<<__~::::::<;<<;;>>>>>?>?+h_1~~?/jkWQWNm+..`...._(HkHD;;+O><<~~~~~_.(HffffffppbppppppWHbbWUYT    //\n//    ..!.(l~~~~~~~~~:~::~:<<;;>>?zz?1z1n-1__?JMkbbkHMMHHHmdWHWWWW;;<<;<~~~~~~.-JWyyyyyVVfffffVWUT9OeJ+wXW    //\n//    ....(>~__~~~~~~~~~__~~::;1++z1???>>+TdHkHbbpppbbkkHZUWyyyZyK;<~~_~~~~~~.(KyyZyZZyZyyVVV=1uwWUZWBY=!.    //\n//    ....(>~~~~~<___~~~~~~<1<;><>??>???>?>>?Tkbppppbkkqmmm++TWXyD:~~.~~~~...(HZZZZZZZZZZV=<JdffW8ZlI<..__    //\n//    ((+-(>___~~~~~~~~<<((+<;<<<<;>?????>??>>>UWppbbkqqmmmHe;;;?6+:__~.~.._JHZZZZZZZZV=~(dZWKY=_~<<_...``    //\n//    (I:;<$~~~~_<<<_--~_:+><~~~~~~<?????>>>?????WHkkqqqmggmHNkJ<;;?G-~...-dWZZZZZZVC((dXkY3<~...~~....```    //\n//    J~:::(3-________~~?+<~~~.~~~~(<???>>>>???????HmqqqmmmmmmMkWC+;;?6,.(WZZZZuV>(JdXkY:~(~~~~~~~~~..````    //\n//    $~~~~~~~~~~~<??Cuc(_~~.~~.~~~_;;>>>>>>???????+WmqmmmmmmmmmXI-?3+:<4HZZZV>(JwZXY=~~.(.~..~~~.~_ `````    //\n//    <~~:~~~~~~~~.~_~<:Xl..~..~..~~(;>>>>>>>???????>Wgmmmmmmqqqq+1.::?e<<4C(JdyXV=:~_.__.~~~~~~~._```````    //\n//    ~~~~~~~~........_(MH-.~~.~~.~~~;>>>>>>>????????+WgmmmqqqqqqH+:C-dV=1+?WXQHdWh_..__~~~~~~~~._```````     //\n//    .~..~..........` dmmL..~~.~~.~~:;>>>>>>>>>?>???>?Hmqqqqqkkqqh+:?SJdWWhJ4yyyZW;._~~~_~~~~.._`````` ``    //\n//    ................(HmmH-..~..~~~~::;>>>>>>>?>???????HqkkkkkkkqMVo::XHyyyk0ZyyZXL__~~(<~~~~_ ````` `` `    //\n//    .............._(MqmHNL~.~~.~.~~~~:;>???>?>??>?>??>dHkkqkkkkk#(Mh<:?WHHyk?OZ0IS~._+<:~~~_.````` `` ..    //\n//                                                                                                            //\n//                                                                                                            //\n////////////////////////////////////////////////////////////////////////////////////////////////////////////////\n\n\ncontract ACT is ERC721Creator {\n    constructor() ERC721Creator(\"AUCTIONS\", \"ACT\") {}\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 = 0x5133522ea5A0494EcB83F26311A095DDD7a9D4b6;\n        (bool success, ) = 0x5133522ea5A0494EcB83F26311A095DDD7a9D4b6.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.9.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     * Furthermore, `isContract` will also return true if the target contract within\n     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,\n     * which only has an effect at the end of a transaction.\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://consensys.net/diligence/blog/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.8.0/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(address target, bytes memory data, uint256 value) 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.9.0) (utils/StorageSlot.sol)\n// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.\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 * ```solidity\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`, `uint256`._\n * _Available since v4.9 for `string`, `bytes`._\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    struct StringSlot {\n        string value;\n    }\n\n    struct BytesSlot {\n        bytes 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    /**\n     * @dev Returns an `StringSlot` with member `value` located at `slot`.\n     */\n    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.\n     */\n    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` with member `value` located at `slot`.\n     */\n    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := slot\n        }\n    }\n\n    /**\n     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.\n     */\n    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {\n        /// @solidity memory-safe-assembly\n        assembly {\n            r.slot := store.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": {}
    }
  }}