{"matchId":"10799566","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2025-12-12T14:17:18Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"508:4405:13:-:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;508:4405:13;;-1:-1:-1;;508:4405:13;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;2046:13:3;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;2046:13:3;508:4405:13;;;;-1:-1:-1;;;;;508:4405:13;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;2069:17:3;508:4405:13;;494:8:5;;508:4405:13;;;538:11:5;-1:-1:-1;;;;;508:4405:13;;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;;7669:23:0;7665:149;;508:4405:13;-1:-1:-1;;;;;;508:4405:13;;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;;7669:23:0;7665:149;;508:4405:13;-1:-1:-1;;;;;;;;;;;;;508:4405:13;;;3130:6:0;508:4405:13;;4604:22:0;508:4405:13;;;;;;;;;679:24;;;7360:52:0;;-1:-1:-1;7360:52:0;-1:-1:-1;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;2274:20:2;508:4405:13;;;734:10:7;508:4405:13;;2274:20:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;508:4405:13;;;2046:13:3;508:4405:13;;;;;;;;-1:-1:-1;;;508:4405:13;;;;;;;7665:149:0;-1:-1:-1;;;;;508:4405:13;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;-1:-1:-1;;508:4405:13;;;;;734:10:7;;508:4405:13;-1:-1:-1;;;;;;;;;;;679:24:13;-1:-1:-1;;;;;;;;;;;7763:40:0;-1:-1:-1;7763:40:0;7665:149;;;;-1:-1:-1;;;;;508:4405:13;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;-1:-1:-1;;508:4405:13;;;;;734:10:7;;508:4405:13;-1:-1:-1;;;;;;;;;;;;;7763:40:0;7665:149;;;508:4405:13;;;-1:-1:-1;;;508:4405:13;;;2046:13:3;508:4405:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;2069:17:3;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:17:3;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;2069:17:3;508:4405:13;;;;;;;;;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;-1:-1:-1;508:4405:13;;2046:13:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;2046:13:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;2046:13:3;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;;;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;2046:13:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2046:13:3;-1:-1:-1;508:4405:13;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;;508:4405:13;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;;:::o;:::-;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;-1:-1:-1;;508:4405:13;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;:::o","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":11365,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000204fce5e3e250261100000000000000000000000000000009d8796b0ac1064ede1378d785df96970eaf5a2b90000000000000000000000009d8796b0ac1064ede1378d785df96970eaf5a2b9000000000000000000000000000000000000000000000000000000000000000f424e42204174746573746174696f6e000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000034241530000000000000000000000000000000000000000000000000000000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"508:4405:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;2185:20;;508:4405;;-1:-1:-1;508:4405:13;;;;;;;;;;;;7669:23:0;7665:149;;508:4405:13;;;7665:149:0;-1:-1:-1;508:4405:13;;;;;;;;;;;;;7740:4:0;508:4405:13;;;734:10:7;;508:4405:13;610:24;;7763:40:0;;-1:-1:-1;7763:40:0;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;679:24;508:4405;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;3035:21;;508:4405;;;;;3104:14;508:4405;;;;;3130:4;508:4405;;;;;;;3149:31;508:4405;;;3130:4;508:4405;;3149:31;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;4102:11:3;508:4405:13;;;4102:27:3;508:4405:13;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;5486:7:0;508:4405:13;;;;:::i;:::-;5438:18:0;2642:4;5438:18;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;5438:18;2642:4;:::i;:::-;5486:7;:::i;:::-;508:4405:13;;;;;;;;;;;;;;;;;610:24;508:4405;;;;;;;;;;;;;;;3894:6:3;508:4405:13;;:::i;:::-;;;734:10:7;;3894:6:3;:::i;:::-;508:4405:13;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;734:10:7;;508:4405:13;;4102:11:3;508:4405:13;;;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;6792:35:3;;;;508:4405:13;;6928:34:3;508:4405:13;;734:10:7;;6928:34:3;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;2457:7:3;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:3;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;3130:6:0;508:4405:13;;;3130:29:0;508:4405:13;-1:-1:-1;508:4405:13;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;3422:21;;508:4405;;;;;3494:14;508:4405;;;;;;;;;;;3540:32;508:4405;;;;;;3540:32;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2642:4:0;;:::i;:::-;508:4405:13;;;;;;;;2255:4:2;508:4405:13;;;;;2274:20:2;508:4405:13;;;734:10:7;508:4405:13;;2274:20:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3519:9:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;610:24;508:4405;;3130:6:0;508:4405:13;;;;;;734:10:7;508:4405:13;;;;;;;;;;;3931:23:0;3927:390;;3342:12:3;508:4405:13;861:28:5;;;;;:::i;:::-;705:4;-1:-1:-1;508:4405:13;;;;8603:21:3;;;508:4405:13;;;;;;3803:234;;508:4405;;8731:22:3;;;;8952:37;8731:22;;:::i;:::-;3342:12;508:4405:13;;;;;;;;;;;;;;;;;;;;;8952:37:3;508:4405:13;;3803:234;508:4405;;;;8731:22:3;508:4405:13;;8952:37:3;508:4405:13;;3903:14;508:4405;;;;;;;;3903:42;;3803:234;;;;;;;;;;3903:42;508:4405;;;3903:14;508:4405;;3903:42;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3927:390:0;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;610:24:13;4214:38:0;:::i;:::-;508:4405:13;;;;4022:252:0;;;508:4405:13;;4022:252:0;;508:4405:13;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;4022:252:0;;;;;;;;;:::i;:::-;508:4405:13;;3970:336:0;;;;;;508:4405:13;3970:336:0;;;:::i;:::-;;;;508:4405:13;;;;;;;;;;;;2642:4:0;;:::i;:::-;508:4405:13;;;;;;;;;;;;2521:22:2;508:4405:13;;;734:10:7;508:4405:13;;2521:22:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2785:14;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;6021:38:3;508:4405:13;6021:38:3;508:4405:13;;;:::i;:::-;734:10:7;;508:4405:13;;4102:11:3;508:4405:13;;;;;;;;;;;;;;;;;6021:38:3;:::i;:::-;734:10:7;;6021:38:3;:::i;508:4405:13:-;;;;;;;;;;;;;;:::i;:::-;734:10:7;508:4405:13;;;6133:23:0;508:4405:13;;6237:7:0;508:4405:13;;;6237:7:0;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;705:4:5;508:4405:13;;;;;;;;;;;;;;;;;;3186:2:3;508:4405:13;;;;;;;;;;;;;;;;;;;:::i;:::-;5012:18:0;2642:4;5012:18;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;2642:4;508:4405:13;;;3130:6:0;508:4405:13;;;;;;;;;;;;;;;;;;7669:23:0;7665:149;;508:4405:13;;;7665:149:0;508:4405:13;;;3130:6:0;508:4405:13;;;;;;;;;;;;;;;7740:4:0;508:4405:13;;;;;;;;734:10:7;508:4405:13;;7763:40:0;;;;;7665:149;;508:4405:13;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;508:4405:13;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;4102:11:3;508:4405:13;;;;;;734:10:7;508:4405:13;;;;;;;11244:37:3;11264:17;11244:37;;11240:243;;508:4405:13;5424:6:3;;;;:::i;11240:243::-;11305:26;;;508:4405:13;;11432:25:3;508:4405:13;5424:6:3;508:4405:13;;734:10:7;11432:25:3;;:::i;:::-;11240:243;;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3342:12:3;508:4405:13;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;;;;:::i;:::-;508:4405:13;4563:16;;;508:4405;;;;4629:19;;;508:4405;;4699:10;;508:4405;;;;;4771:34;;;508:4405;4771:34;;508:4405;;;;;;;4771:34;;;;;;;;;;;;;;;;508:4405;;;;;;4871:33;508:4405;;;;;;4871:33;508:4405;;;;;;;;;;;;;;;;;;;;4771:34;508:4405;;;;4771:34;;;508:4405;4771:34;;508:4405;4771:34;;;;;;508:4405;4771:34;;;:::i;:::-;;;508:4405;;;;;;;;;;;;4771:34;;;508:4405;;;;4771:34;;;-1:-1:-1;4771:34:13;;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4606:6:3;508:4405:13;;:::i;:::-;;;734:10:7;;4606:6:3;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2840:47:0;;2855:32;2840:47;;:87;;;;;508:4405:13;;;;;;;2840:87:0;952:25:9;937:40;;;2840:87:0;;;508:4405:13;;;;;;;;;;;;;;;;-1:-1:-1;;508:4405:13;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;:::o;:::-;;;;;;;;;;10457:340:3;508:4405:13;;10558:19:3;;;508:4405:13;;;;10636:21:3;;;508:4405:13;;;10758:32:3;508:4405:13;;10575:1:3;508:4405:13;10707:11:3;508:4405:13;;;10575:1:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;10758:32:3;10457:340::o;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3460:103:0;734:10:7;508:4405:13;;;;;;;;;;;;;3931:23:0;3927:390;;3460:103::o;3927:390::-;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;508:4405:13;4214:38:0;:::i;3460:103::-;734:10:7;-1:-1:-1;508:4405:13;;;;;;;;;;;;3931:23:0;3927:390;;3460:103::o;3927:390::-;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;679:24:13;4214:38:0;:::i;3460:103::-;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;734:10:7;508:4405:13;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;3931:23:0;3927:390;;3460:103;:::o;3927:390::-;3970:336;734:10:7;4022:252:0;508:4405:13;4214:38:0;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4214:38:0;;:::i;7456:788:3:-;508:4405:13;;7552:18:3;;;508:4405:13;;7552:18:3;508:4405:13;;;;7630:16:3;;;508:4405:13;;;7568:1:3;508:4405:13;;3803:234;;7456:788:3;508:4405:13;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;7568:1:3;508:4405:13;;7801:21:3;;;508:4405:13;;;8163:26:3;508:4405:13;;;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;;7568:1:3;508:4405:13;;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;7568:1:3;508:4405:13;;;;;;;;;;;;8163:26:3;7456:788::o;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;3803:234;508:4405;7568:1:3;508:4405:13;3903:14;508:4405;;;;7568:1:3;508:4405:13;;;3903:42;;;3803:234;7568:1:3;7552:18;;3967:28:13;;3803:234;508:4405;;;;3803:234;;;508:4405;;;;;;;;;;;;;;;;;;;;;;;3967:28;;;;;;3903:42;508:4405;;7568:1:3;508:4405:13;3903:14;508:4405;;;;7568:1:3;508:4405:13;;;3903:42;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7991:234:0;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;8070:149:0;;7991:234;;:::o;8070:149::-;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;;;;734:10:7;508:4405:13;;8168:40:0;;-1:-1:-1;8168:40:0;;7991:234::o;508:4405:13:-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;1818:437:8;-1:-1:-1;508:4405:13;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;1975:15:8;;;508:4405:13;;;;;;;2000:15:8;508:4405:13;;;2000:15:8;-1:-1:-1;508:4405:13;-1:-1:-1;2058:5:8;508:4405:13;2058:5:8;;;;2170:10;;278:18;;1818:437;:::o;278:18::-;;508:4405:13;;278:18:8;;;508:4405:13;2141:1:8;278:18;;;508:4405:13;278:18:8;;;508:4405:13;278:18:8;508:4405:13;;;278:18:8;;2065:3;2105:11;;2113:3;2105:11;;2096:21;;;;;;508:4405:13;2096:21:8;;2084:33;;;;:::i;:::-;;2141:1;278:18;2065:3;508:4405:13;;;;;;2030:26:8;;;508:4405:13;;;;;;;2141:1:8;508:4405:13;;2096:21:8;508:4405:13;;;;;;2141:1:8;508:4405:13;;;;;;;;;;;;;;;;;;;;;;1818:437:8;-1:-1:-1;508:4405:13;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;1975:15:8;;;508:4405:13;;;;;;;2000:15:8;508:4405:13;;;2000:15:8;-1:-1:-1;508:4405:13;-1:-1:-1;2058:5:8;508:4405:13;2058:5:8;;;;2170:10;;278:18;;1818:437;:::o;2065:3::-;2105:11;;2113:3;2105:11;;2096:21;;;;;;508:4405:13;2096:21:8;;2084:33;;;;:::i;:::-;;2141:1;278:18;2065:3;508:4405:13;;;;;;2030:26:8;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa164736f6c634300081a000a","offset":9640}},"immutableReferences":{"1169":[{"start":3249,"length":32},{"start":4710,"length":32}]},"transformations":[{"id":"1169","type":"replace","offset":3249,"reason":"immutable"},{"id":"1169","type":"replace","offset":4710,"reason":"immutable"}],"transformationValues":{"immutables":{"1169":"0x0000000000000000000000000000000000000000204fce5e3e25026110000000"}}},"deployment":{"transactionHash":"0x5368d4291e1b1427f0f61abe80ff515c5814e88f573a35dd71f4754accfd1c72","blockNumber":"53994920","transactionIndex":"117","deployer":"0x9d8796B0AC1064ede1378D785df96970eAf5A2B9"},"sources":{"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControl.sol\";\nimport \"../utils/Context.sol\";\nimport \"../utils/Strings.sol\";\nimport \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        Strings.toHexString(account),\n                        \" is missing role \",\n                        Strings.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * May emit a {RoleGranted} event.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n}\n"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n"},"@openzeppelin/contracts/security/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.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 *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\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 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    /**\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 `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, 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 `from` to `to` 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(address from, address to, uint256 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20.sol\";\n\n/**\n * @dev Extension of {ERC20} that adds a cap to the supply of tokens.\n */\nabstract contract ERC20Capped is ERC20 {\n    uint256 private immutable _cap;\n\n    /**\n     * @dev Sets the value of the `cap`. This value is immutable, it can only be\n     * set once during construction.\n     */\n    constructor(uint256 cap_) {\n        require(cap_ > 0, \"ERC20Capped: cap is 0\");\n        _cap = cap_;\n    }\n\n    /**\n     * @dev Returns the cap on the token's total supply.\n     */\n    function cap() public view virtual returns (uint256) {\n        return _cap;\n    }\n\n    /**\n     * @dev See {ERC20-_mint}.\n     */\n    function _mint(address account, uint256 amount) internal virtual override {\n        require(ERC20.totalSupply() + amount <= cap(), \"ERC20Capped: cap exceeded\");\n        super._mint(account, amount);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\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"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\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 Context {\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    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.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 `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\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    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\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.9.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(uint256 x, uint256 y, uint256 denominator) 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                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\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(uint256 x, uint256 y, uint256 denominator, Rounding rounding) 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 256, 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 << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"contracts/bas/BAS.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {ERC20,IERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {ERC20Capped} from \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol\";\nimport {AccessControl} from \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/security/Pausable.sol\";\n\n/// @title BAS Token Contract\n/// @notice Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.\ncontract BASToken is Pausable, ERC20Capped, AccessControl {\n    bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n\n    bytes32 public constant PAUSER_ROLE = keccak256(\"PAUSER_ROLE\");\n\n    mapping(address => bool) private _isWhitelisted;\n\n    event WhitelistUpdated(address indexed account, bool isWhitelisted);\n\n    /// @notice Initializes the contract.\n    /// @param name The name of the token.\n    /// @param symbol The symbol of the token.\n    /// @param cap The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).\n    /// @param admin The address to be set as the default admin of the token.\n    /// @param pauser The address to be set as the pauser\n    constructor(\n        string memory name,\n        string memory symbol,\n        uint256 cap,\n        address admin,\n        address pauser\n    ) ERC20(name, symbol) ERC20Capped(cap) {\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n        _grantRole(PAUSER_ROLE, pauser);\n        _setRoleAdmin(PAUSER_ROLE, PAUSER_ROLE);\n        _pause();\n    }\n\n    /// @notice Allows the pause controller address to pause all token transfers for non-whitelisted addresses.\n    function pause() external onlyRole(PAUSER_ROLE) {\n        _pause();\n    }\n\n    /// @notice Allows the pause controller address to unpause the token transfers.\n    function unpause() external onlyRole(PAUSER_ROLE) {\n        _unpause();\n    }\n\n    /// @notice Set the minter address by granting MINTER_ROLE to the specified address.\n    /// @param minter The address to be granted the MINTER_ROLE.\n    function setMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(minter != address(0), \"Minter cannot be zero address\");\n        _grantRole(MINTER_ROLE, minter);\n    }\n\n    /// @notice Allows the minter to mint new tokens, up to the cap.\n    /// @param to The address that will receive the minted tokens.\n    /// @param amount The amount of tokens to mint.\n    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {\n        _mint(to, amount);\n    }\n\n    /// @notice Returns true if the account is whitelisted.\n    /// @param account The address to check.\n    function isWhitelisted(address account) external view returns (bool) {\n        return _isWhitelisted[account];\n    }\n\n    /// @notice Adds an address to the whitelist.\n    /// @param account The address to add to the whitelist.\n    function addToWhitelist(\n        address account\n    ) external onlyRole(PAUSER_ROLE) {\n        require(account != address(0), \"cannot whitelist the zero address\");\n        _isWhitelisted[account] = true;\n        emit WhitelistUpdated(account, true);\n    }\n\n    /// @notice Removes an address from the whitelist.\n    /// @param account The address to remove from the whitelist.\n    function removeFromWhitelist(\n        address account\n    ) external onlyRole(PAUSER_ROLE) {\n        require(account != address(0), \"cannot un-whitelist the zero address\");\n        _isWhitelisted[account] = false;\n        emit WhitelistUpdated(account, false);\n    }\n\n    /// @notice Checks if the contract is paused before every transfer, mint, or burn, and verifies whitelist status.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {\n        if (paused()) {\n            bool minting = from == address(0);\n            bool whitelistTransfer = _isWhitelisted[from] && _isWhitelisted[to];\n            require(minting || whitelistTransfer, \"paused and not whitelisted\");\n        }\n        super._beforeTokenTransfer(from, to, amount);\n    }\n\n\n    /// @notice Recover ERC20 tokens mistakenly sent to this contract.\n    /// @param token The address of the ERC20 token contract.\n    /// @param to The address to receive the recovered tokens.\n    /// @param amount The amount of tokens to recover.\n    event ERC20Recovered(address indexed token, address indexed to, uint256 amount);\n\n\n    function recoverERC20(address token, address to, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(to != address(0), \"cannot send to zero address\");\n        require(token != address(0), \"token address cannot be zero\");\n        require(amount > 0, \"amount must be greater than zero\");\n        bool success = IERC20(token).transfer(to, amount);\n        require(success, \"ERC20 transfer failed\");\n        emit ERC20Recovered(token, to, amount);\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.26+commit.8a97fa7a","compilerSettings":{"viaIR":true,"metadata":{"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"paris","remappings":[]},"name":"BASToken","fullyQualifiedName":"contracts/bas/BAS.sol:BASToken"},"abi":[{"type":"constructor","inputs":[{"name":"name","type":"string","internalType":"string"},{"name":"symbol","type":"string","internalType":"string"},{"name":"cap","type":"uint256","internalType":"uint256"},{"name":"admin","type":"address","internalType":"address"},{"name":"pauser","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ERC20Recovered","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"WhitelistUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"isWhitelisted","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"MINTER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"PAUSER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"addToWhitelist","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"cap","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"isWhitelisted","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"recoverERC20","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeFromWhitelist","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.26+commit.8a97fa7a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"cap","type":"uint256"},{"internalType":"address","name":"admin","type":"address"},{"internalType":"address","name":"pauser","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20Recovered","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isWhitelisted","type":"bool"}],"name":"WhitelistUpdated","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"addToWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"recoverERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"removeFromWhitelist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"minter","type":"address"}],"name":"setMinter","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}],"devdoc":{"events":{"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"ERC20Recovered(address,address,uint256)":{"params":{"amount":"The amount of tokens to recover.","to":"The address to receive the recovered tokens.","token":"The address of the ERC20 token contract."}},"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._"},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."}},"kind":"dev","methods":{"addToWhitelist(address)":{"params":{"account":"The address to add to the whitelist."}},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"cap()":{"details":"Returns the cap on the token's total supply."},"constructor":{"params":{"admin":"The address to be set as the default admin of the token.","cap":"The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).","name":"The name of the token.","pauser":"The address to be set as the pauser","symbol":"The symbol of the token."}},"decimals()":{"details":"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 default value returned by this function, unless it's 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}."},"decreaseAllowance(address,uint256)":{"details":"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`."},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"increaseAllowance(address,uint256)":{"details":"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."},"isWhitelisted(address)":{"params":{"account":"The address to check."}},"mint(address,uint256)":{"params":{"amount":"The amount of tokens to mint.","to":"The address that will receive the minted tokens."}},"name()":{"details":"Returns the name of the token."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"removeFromWhitelist(address)":{"params":{"account":"The address to remove from the whitelist."}},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"setMinter(address)":{"params":{"minter":"The address to be granted the MINTER_ROLE."}},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"title":"BAS Token Contract","version":1},"userdoc":{"events":{"ERC20Recovered(address,address,uint256)":{"notice":"Recover ERC20 tokens mistakenly sent to this contract."}},"kind":"user","methods":{"addToWhitelist(address)":{"notice":"Adds an address to the whitelist."},"constructor":{"notice":"Initializes the contract."},"isWhitelisted(address)":{"notice":"Returns true if the account is whitelisted."},"mint(address,uint256)":{"notice":"Allows the minter to mint new tokens, up to the cap."},"pause()":{"notice":"Allows the pause controller address to pause all token transfers for non-whitelisted addresses."},"removeFromWhitelist(address)":{"notice":"Removes an address from the whitelist."},"setMinter(address)":{"notice":"Set the minter address by granting MINTER_ROLE to the specified address."},"unpause()":{"notice":"Allows the pause controller address to unpause the token transfers."}},"notice":"Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.","version":1}},"settings":{"compilationTarget":{"contracts/bas/BAS.sol":"BASToken"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":1000000},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts/access/AccessControl.sol":{"keccak256":"0x0dd6e52cb394d7f5abe5dca2d4908a6be40417914720932de757de34a99ab87f","license":"MIT","urls":["bzz-raw://dc117ce50ea746cab6b97ed1a1facee17a715ae0cb95d67b943dacbaf15176fb","dweb:/ipfs/QmYRZ2UGNYwsHwfNu7Wjr8L2j1LBZ1mKv6NvbwgterYMXc"]},"@openzeppelin/contracts/access/IAccessControl.sol":{"keccak256":"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57","license":"MIT","urls":["bzz-raw://bb2c137c343ef0c4c7ce7b18c1d108afdc9d315a04e48307288d2d05adcbde3a","dweb:/ipfs/QmUxhrAQM3MM3FF5j7AtcXLXguWCJBHJ14BRdVtuoQc8Fh"]},"@openzeppelin/contracts/security/Pausable.sol":{"keccak256":"0x0849d93b16c9940beb286a7864ed02724b248b93e0d80ef6355af5ef15c64773","license":"MIT","urls":["bzz-raw://4ddabb16009cd17eaca3143feadf450ac13e72919ebe2ca50e00f61cb78bc004","dweb:/ipfs/QmSPwPxX7d6TTWakN5jy5wsaGkS1y9TW8fuhGSraMkLk2B"]},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"keccak256":"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c","license":"MIT","urls":["bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15","dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih"]},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"keccak256":"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305","license":"MIT","urls":["bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5","dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53"]},"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol":{"keccak256":"0x3fe04ed1daf0f12454333fde982a25b103860d8a010dd5d8479b83ebf1dfb788","license":"MIT","urls":["bzz-raw://8322152771e94c9e28a3bd9e7c9d5dd4fdd00ae214f95915962a6638d8dfc7d6","dweb:/ipfs/QmaXJvF3UjRHacx3nPgt94DwAuXCkEoz6fS7MLr2jbuJyW"]},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"keccak256":"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca","license":"MIT","urls":["bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd","dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8"]},"@openzeppelin/contracts/utils/Context.sol":{"keccak256":"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439","license":"MIT","urls":["bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c","dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h"]},"@openzeppelin/contracts/utils/Strings.sol":{"keccak256":"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0","license":"MIT","urls":["bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f","dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n"]},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"keccak256":"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b","license":"MIT","urls":["bzz-raw://fb0048dee081f6fffa5f74afc3fb328483c2a30504e94a0ddd2a5114d731ec4d","dweb:/ipfs/QmZptt1nmYoA5SgjwnSgWqgUSDgm4q52Yos3xhnMv3MV43"]},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1","license":"MIT","urls":["bzz-raw://be161e54f24e5c6fae81a12db1a8ae87bc5ae1b0ddc805d82a1440a68455088f","dweb:/ipfs/QmP7C3CHdY9urF4dEMb9wmsp1wMxHF6nhA2yQE5SKiPAdy"]},"@openzeppelin/contracts/utils/math/Math.sol":{"keccak256":"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3","license":"MIT","urls":["bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c","dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS"]},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"keccak256":"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc","license":"MIT","urls":["bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7","dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6"]},"contracts/bas/BAS.sol":{"keccak256":"0x34abdd99c82eb94d458fdec8bb651f3e92b6dffd3ff21a237b5b6f72d01dba6d","license":"MIT","urls":["bzz-raw://1eab537561884c9d42e028f1970e52c8bdc3b4eee3893fed516e5758052f84ae","dweb:/ipfs/QmbrMsK8QPiczfFXPynRQNGbappNfgFGHjCpgk39WqJFzp"]}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_struct(RoleData)19_storage":{"label":"struct AccessControl.RoleData","members":[{"slot":"0","type":"t_mapping(t_address,t_bool)","astId":16,"label":"members","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"1","type":"t_bytes32","astId":18,"label":"adminRole","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"}],"encoding":"inplace","numberOfBytes":"64"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(RoleData)19_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct AccessControl.RoleData)","value":"t_struct(RoleData)19_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_bool","astId":406,"label":"_paused","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"1","type":"t_mapping(t_address,t_uint256)","astId":512,"label":"_balances","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":518,"label":"_allowances","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"3","type":"t_uint256","astId":520,"label":"_totalSupply","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"4","type":"t_string_storage","astId":522,"label":"_name","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"5","type":"t_string_storage","astId":524,"label":"_symbol","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"6","type":"t_mapping(t_bytes32,t_struct(RoleData)19_storage)","astId":24,"label":"_roles","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"7","type":"t_mapping(t_address,t_bool)","astId":2549,"label":"_isWhitelisted","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","events":{"ERC20Recovered(address,address,uint256)":{"notice":"Recover ERC20 tokens mistakenly sent to this contract."}},"notice":"Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.","methods":{"pause()":{"notice":"Allows the pause controller address to pause all token transfers for non-whitelisted addresses."},"unpause()":{"notice":"Allows the pause controller address to unpause the token transfers."},"constructor":{"notice":"Initializes the contract."},"setMinter(address)":{"notice":"Set the minter address by granting MINTER_ROLE to the specified address."},"mint(address,uint256)":{"notice":"Allows the minter to mint new tokens, up to the cap."},"isWhitelisted(address)":{"notice":"Returns true if the account is whitelisted."},"addToWhitelist(address)":{"notice":"Adds an address to the whitelist."},"removeFromWhitelist(address)":{"notice":"Removes an address from the whitelist."}},"version":1},"devdoc":{"kind":"dev","title":"BAS Token Contract","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"ERC20Recovered(address,address,uint256)":{"params":{"to":"The address to receive the recovered tokens.","token":"The address of the ERC20 token contract.","amount":"The amount of tokens to recover."}},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._"}},"methods":{"cap()":{"details":"Returns the cap on the token's total supply."},"name()":{"details":"Returns the name of the token."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"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 default value returned by this function, unless it's 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}."},"constructor":{"params":{"cap":"The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).","name":"The name of the token.","admin":"The address to be set as the default admin of the token.","pauser":"The address to be set as the pauser","symbol":"The symbol of the token."}},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"setMinter(address)":{"params":{"minter":"The address to be granted the MINTER_ROLE."}},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"mint(address,uint256)":{"params":{"to":"The address that will receive the minted tokens.","amount":"The amount of tokens to mint."}},"isWhitelisted(address)":{"params":{"account":"The address to check."}},"addToWhitelist(address)":{"params":{"account":"The address to add to the whitelist."}},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"removeFromWhitelist(address)":{"params":{"account":"The address to remove from the whitelist."}},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event."},"decreaseAllowance(address,uint256)":{"details":"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`."},"increaseAllowance(address,uint256)":{"details":"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."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"sourceIds":{"contracts/bas/BAS.sol":{"id":13},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/utils/Strings.sol":{"id":8},"@openzeppelin/contracts/utils/math/Math.sol":{"id":11},"@openzeppelin/contracts/security/Pausable.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":4},"@openzeppelin/contracts/access/AccessControl.sol":{"id":0},"@openzeppelin/contracts/access/IAccessControl.sol":{"id":1},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":12},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol":{"id":5},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/bas/BAS.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.26;\n\nimport {ERC20,IERC20} from \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport {ERC20Capped} from \"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol\";\nimport {AccessControl} from \"@openzeppelin/contracts/access/AccessControl.sol\";\nimport {Pausable} from \"@openzeppelin/contracts/security/Pausable.sol\";\n\n/// @title BAS Token Contract\n/// @notice Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.\ncontract BASToken is Pausable, ERC20Capped, AccessControl {\n    bytes32 public constant MINTER_ROLE = keccak256(\"MINTER_ROLE\");\n\n    bytes32 public constant PAUSER_ROLE = keccak256(\"PAUSER_ROLE\");\n\n    mapping(address => bool) private _isWhitelisted;\n\n    event WhitelistUpdated(address indexed account, bool isWhitelisted);\n\n    /// @notice Initializes the contract.\n    /// @param name The name of the token.\n    /// @param symbol The symbol of the token.\n    /// @param cap The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).\n    /// @param admin The address to be set as the default admin of the token.\n    /// @param pauser The address to be set as the pauser\n    constructor(\n        string memory name,\n        string memory symbol,\n        uint256 cap,\n        address admin,\n        address pauser\n    ) ERC20(name, symbol) ERC20Capped(cap) {\n        _grantRole(DEFAULT_ADMIN_ROLE, admin);\n        _grantRole(PAUSER_ROLE, pauser);\n        _setRoleAdmin(PAUSER_ROLE, PAUSER_ROLE);\n        _pause();\n    }\n\n    /// @notice Allows the pause controller address to pause all token transfers for non-whitelisted addresses.\n    function pause() external onlyRole(PAUSER_ROLE) {\n        _pause();\n    }\n\n    /// @notice Allows the pause controller address to unpause the token transfers.\n    function unpause() external onlyRole(PAUSER_ROLE) {\n        _unpause();\n    }\n\n    /// @notice Set the minter address by granting MINTER_ROLE to the specified address.\n    /// @param minter The address to be granted the MINTER_ROLE.\n    function setMinter(address minter) external onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(minter != address(0), \"Minter cannot be zero address\");\n        _grantRole(MINTER_ROLE, minter);\n    }\n\n    /// @notice Allows the minter to mint new tokens, up to the cap.\n    /// @param to The address that will receive the minted tokens.\n    /// @param amount The amount of tokens to mint.\n    function mint(address to, uint256 amount) external onlyRole(MINTER_ROLE) {\n        _mint(to, amount);\n    }\n\n    /// @notice Returns true if the account is whitelisted.\n    /// @param account The address to check.\n    function isWhitelisted(address account) external view returns (bool) {\n        return _isWhitelisted[account];\n    }\n\n    /// @notice Adds an address to the whitelist.\n    /// @param account The address to add to the whitelist.\n    function addToWhitelist(\n        address account\n    ) external onlyRole(PAUSER_ROLE) {\n        require(account != address(0), \"cannot whitelist the zero address\");\n        _isWhitelisted[account] = true;\n        emit WhitelistUpdated(account, true);\n    }\n\n    /// @notice Removes an address from the whitelist.\n    /// @param account The address to remove from the whitelist.\n    function removeFromWhitelist(\n        address account\n    ) external onlyRole(PAUSER_ROLE) {\n        require(account != address(0), \"cannot un-whitelist the zero address\");\n        _isWhitelisted[account] = false;\n        emit WhitelistUpdated(account, false);\n    }\n\n    /// @notice Checks if the contract is paused before every transfer, mint, or burn, and verifies whitelist status.\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal override {\n        if (paused()) {\n            bool minting = from == address(0);\n            bool whitelistTransfer = _isWhitelisted[from] && _isWhitelisted[to];\n            require(minting || whitelistTransfer, \"paused and not whitelisted\");\n        }\n        super._beforeTokenTransfer(from, to, amount);\n    }\n\n\n    /// @notice Recover ERC20 tokens mistakenly sent to this contract.\n    /// @param token The address of the ERC20 token contract.\n    /// @param to The address to receive the recovered tokens.\n    /// @param amount The amount of tokens to recover.\n    event ERC20Recovered(address indexed token, address indexed to, uint256 amount);\n\n\n    function recoverERC20(address token, address to, uint256 amount) external onlyRole(DEFAULT_ADMIN_ROLE) {\n        require(to != address(0), \"cannot send to zero address\");\n        require(token != address(0), \"token address cannot be zero\");\n        require(amount > 0, \"amount must be greater than zero\");\n        bool success = IERC20(token).transfer(to, amount);\n        require(success, \"ERC20 transfer failed\");\n        emit ERC20Recovered(token, to, amount);\n    }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.4) (utils/Context.sol)\n\npragma solidity ^0.8.0;\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 Context {\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    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/Strings.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./math/Math.sol\";\nimport \"./math/SignedMath.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 `int256` to its ASCII `string` decimal representation.\n     */\n    function toString(int256 value) internal pure returns (string memory) {\n        return string(abi.encodePacked(value < 0 ? \"-\" : \"\", toString(SignedMath.abs(value))));\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    /**\n     * @dev Returns true if the two strings are equal.\n     */\n    function equal(string memory a, string memory b) internal pure returns (bool) {\n        return keccak256(bytes(a)) == keccak256(bytes(b));\n    }\n}\n"},"@openzeppelin/contracts/utils/math/Math.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.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(uint256 x, uint256 y, uint256 denominator) 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                // Solidity will revert if denominator == 0, unlike the div opcode on its own.\n                // The surrounding unchecked block does not change this fact.\n                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.\n                return prod0 / denominator;\n            }\n\n            // Make sure the result is less than 2^256. Also prevents denominator == 0.\n            require(denominator > prod1, \"Math: mulDiv overflow\");\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(uint256 x, uint256 y, uint256 denominator, Rounding rounding) 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 256, 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 << 3) < value ? 1 : 0);\n        }\n    }\n}\n"},"@openzeppelin/contracts/security/Pausable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.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 *\n * This module is used through inheritance. It will make available the\n * modifiers `whenNotPaused` and `whenPaused`, which can be applied to\n * the functions of your contract. Note that they will not be pausable by\n * simply including this module, only once the modifiers are put in place.\n */\nabstract contract Pausable is Context {\n    /**\n     * @dev Emitted when the pause is triggered by `account`.\n     */\n    event Paused(address account);\n\n    /**\n     * @dev Emitted when the pause is lifted by `account`.\n     */\n    event Unpaused(address account);\n\n    bool private _paused;\n\n    /**\n     * @dev Initializes the contract in unpaused state.\n     */\n    constructor() {\n        _paused = false;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is not paused.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    modifier whenNotPaused() {\n        _requireNotPaused();\n        _;\n    }\n\n    /**\n     * @dev Modifier to make a function callable only when the contract is paused.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    modifier whenPaused() {\n        _requirePaused();\n        _;\n    }\n\n    /**\n     * @dev Returns true if the contract is paused, and false otherwise.\n     */\n    function paused() public view virtual returns (bool) {\n        return _paused;\n    }\n\n    /**\n     * @dev Throws if the contract is paused.\n     */\n    function _requireNotPaused() internal view virtual {\n        require(!paused(), \"Pausable: paused\");\n    }\n\n    /**\n     * @dev Throws if the contract is not paused.\n     */\n    function _requirePaused() internal view virtual {\n        require(paused(), \"Pausable: not paused\");\n    }\n\n    /**\n     * @dev Triggers stopped state.\n     *\n     * Requirements:\n     *\n     * - The contract must not be paused.\n     */\n    function _pause() internal virtual whenNotPaused {\n        _paused = true;\n        emit Paused(_msgSender());\n    }\n\n    /**\n     * @dev Returns to normal state.\n     *\n     * Requirements:\n     *\n     * - The contract must be paused.\n     */\n    function _unpause() internal virtual whenPaused {\n        _paused = false;\n        emit Unpaused(_msgSender());\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC20.sol\";\nimport \"./extensions/IERC20Metadata.sol\";\nimport \"../../utils/Context.sol\";\n\n/**\n * @dev Implementation of the {IERC20} interface.\n *\n * This implementation is agnostic to the way tokens are created. This means\n * that a supply mechanism has to be added in a derived contract using {_mint}.\n * For a generic mechanism see {ERC20PresetMinterPauser}.\n *\n * TIP: For a detailed writeup see our guide\n * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How\n * to implement supply mechanisms].\n *\n * The default value of {decimals} is 18. To change this, you should override\n * this function so it returns a different value.\n *\n * We have followed general OpenZeppelin Contracts guidelines: functions revert\n * instead returning `false` on failure. This behavior is nonetheless\n * conventional and does not conflict with the expectations of ERC20\n * applications.\n *\n * Additionally, an {Approval} event is emitted on calls to {transferFrom}.\n * This allows applications to reconstruct the allowance for all accounts just\n * by listening to said events. Other implementations of the EIP may not emit\n * these events, as it isn't required by the specification.\n *\n * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}\n * functions have been added to mitigate the well-known issues around setting\n * allowances. See {IERC20-approve}.\n */\ncontract ERC20 is Context, IERC20, IERC20Metadata {\n    mapping(address => uint256) private _balances;\n\n    mapping(address => mapping(address => uint256)) private _allowances;\n\n    uint256 private _totalSupply;\n\n    string private _name;\n    string private _symbol;\n\n    /**\n     * @dev Sets the values for {name} and {symbol}.\n     *\n     * All two of these values are immutable: they can only be set once during\n     * construction.\n     */\n    constructor(string memory name_, string memory symbol_) {\n        _name = name_;\n        _symbol = symbol_;\n    }\n\n    /**\n     * @dev Returns the name of the token.\n     */\n    function name() public view virtual override returns (string memory) {\n        return _name;\n    }\n\n    /**\n     * @dev Returns the symbol of the token, usually a shorter version of the\n     * name.\n     */\n    function symbol() public view virtual override returns (string memory) {\n        return _symbol;\n    }\n\n    /**\n     * @dev Returns the number of decimals used to get its user representation.\n     * For example, if `decimals` equals `2`, a balance of `505` tokens should\n     * be displayed to a user as `5.05` (`505 / 10 ** 2`).\n     *\n     * Tokens usually opt for a value of 18, imitating the relationship between\n     * Ether and Wei. This is the default value returned by this function, unless\n     * it's overridden.\n     *\n     * NOTE: This information is only used for _display_ purposes: it in\n     * no way affects any of the arithmetic of the contract, including\n     * {IERC20-balanceOf} and {IERC20-transfer}.\n     */\n    function decimals() public view virtual override returns (uint8) {\n        return 18;\n    }\n\n    /**\n     * @dev See {IERC20-totalSupply}.\n     */\n    function totalSupply() public view virtual override returns (uint256) {\n        return _totalSupply;\n    }\n\n    /**\n     * @dev See {IERC20-balanceOf}.\n     */\n    function balanceOf(address account) public view virtual override returns (uint256) {\n        return _balances[account];\n    }\n\n    /**\n     * @dev See {IERC20-transfer}.\n     *\n     * Requirements:\n     *\n     * - `to` cannot be the zero address.\n     * - the caller must have a balance of at least `amount`.\n     */\n    function transfer(address to, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _transfer(owner, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-allowance}.\n     */\n    function allowance(address owner, address spender) public view virtual override returns (uint256) {\n        return _allowances[owner][spender];\n    }\n\n    /**\n     * @dev See {IERC20-approve}.\n     *\n     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on\n     * `transferFrom`. This is semantically equivalent to an infinite approval.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function approve(address spender, uint256 amount) public virtual override returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, amount);\n        return true;\n    }\n\n    /**\n     * @dev See {IERC20-transferFrom}.\n     *\n     * Emits an {Approval} event indicating the updated allowance. This is not\n     * required by the EIP. See the note at the beginning of {ERC20}.\n     *\n     * NOTE: Does not update the allowance if the current allowance\n     * is the maximum `uint256`.\n     *\n     * Requirements:\n     *\n     * - `from` and `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     * - the caller must have allowance for ``from``'s tokens of at least\n     * `amount`.\n     */\n    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {\n        address spender = _msgSender();\n        _spendAllowance(from, spender, amount);\n        _transfer(from, to, amount);\n        return true;\n    }\n\n    /**\n     * @dev Atomically increases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     */\n    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        _approve(owner, spender, allowance(owner, spender) + addedValue);\n        return true;\n    }\n\n    /**\n     * @dev Atomically decreases the allowance granted to `spender` by the caller.\n     *\n     * This is an alternative to {approve} that can be used as a mitigation for\n     * problems described in {IERC20-approve}.\n     *\n     * Emits an {Approval} event indicating the updated allowance.\n     *\n     * Requirements:\n     *\n     * - `spender` cannot be the zero address.\n     * - `spender` must have allowance for the caller of at least\n     * `subtractedValue`.\n     */\n    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {\n        address owner = _msgSender();\n        uint256 currentAllowance = allowance(owner, spender);\n        require(currentAllowance >= subtractedValue, \"ERC20: decreased allowance below zero\");\n        unchecked {\n            _approve(owner, spender, currentAllowance - subtractedValue);\n        }\n\n        return true;\n    }\n\n    /**\n     * @dev Moves `amount` of tokens from `from` to `to`.\n     *\n     * This internal function is equivalent to {transfer}, and can be used to\n     * e.g. implement automatic token fees, slashing mechanisms, etc.\n     *\n     * Emits a {Transfer} event.\n     *\n     * Requirements:\n     *\n     * - `from` cannot be the zero address.\n     * - `to` cannot be the zero address.\n     * - `from` must have a balance of at least `amount`.\n     */\n    function _transfer(address from, address to, uint256 amount) internal virtual {\n        require(from != address(0), \"ERC20: transfer from the zero address\");\n        require(to != address(0), \"ERC20: transfer to the zero address\");\n\n        _beforeTokenTransfer(from, to, amount);\n\n        uint256 fromBalance = _balances[from];\n        require(fromBalance >= amount, \"ERC20: transfer amount exceeds balance\");\n        unchecked {\n            _balances[from] = fromBalance - amount;\n            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by\n            // decrementing then incrementing.\n            _balances[to] += amount;\n        }\n\n        emit Transfer(from, to, amount);\n\n        _afterTokenTransfer(from, to, amount);\n    }\n\n    /** @dev Creates `amount` tokens and assigns them to `account`, increasing\n     * the total supply.\n     *\n     * Emits a {Transfer} event with `from` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     */\n    function _mint(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: mint to the zero address\");\n\n        _beforeTokenTransfer(address(0), account, amount);\n\n        _totalSupply += amount;\n        unchecked {\n            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.\n            _balances[account] += amount;\n        }\n        emit Transfer(address(0), account, amount);\n\n        _afterTokenTransfer(address(0), account, amount);\n    }\n\n    /**\n     * @dev Destroys `amount` tokens from `account`, reducing the\n     * total supply.\n     *\n     * Emits a {Transfer} event with `to` set to the zero address.\n     *\n     * Requirements:\n     *\n     * - `account` cannot be the zero address.\n     * - `account` must have at least `amount` tokens.\n     */\n    function _burn(address account, uint256 amount) internal virtual {\n        require(account != address(0), \"ERC20: burn from the zero address\");\n\n        _beforeTokenTransfer(account, address(0), amount);\n\n        uint256 accountBalance = _balances[account];\n        require(accountBalance >= amount, \"ERC20: burn amount exceeds balance\");\n        unchecked {\n            _balances[account] = accountBalance - amount;\n            // Overflow not possible: amount <= accountBalance <= totalSupply.\n            _totalSupply -= amount;\n        }\n\n        emit Transfer(account, address(0), amount);\n\n        _afterTokenTransfer(account, address(0), amount);\n    }\n\n    /**\n     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.\n     *\n     * This internal function is equivalent to `approve`, and can be used to\n     * e.g. set automatic allowances for certain subsystems, etc.\n     *\n     * Emits an {Approval} event.\n     *\n     * Requirements:\n     *\n     * - `owner` cannot be the zero address.\n     * - `spender` cannot be the zero address.\n     */\n    function _approve(address owner, address spender, uint256 amount) internal virtual {\n        require(owner != address(0), \"ERC20: approve from the zero address\");\n        require(spender != address(0), \"ERC20: approve to the zero address\");\n\n        _allowances[owner][spender] = amount;\n        emit Approval(owner, spender, amount);\n    }\n\n    /**\n     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.\n     *\n     * Does not update the allowance amount in case of infinite allowance.\n     * Revert if not enough allowance is available.\n     *\n     * Might emit an {Approval} event.\n     */\n    function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {\n        uint256 currentAllowance = allowance(owner, spender);\n        if (currentAllowance != type(uint256).max) {\n            require(currentAllowance >= amount, \"ERC20: insufficient allowance\");\n            unchecked {\n                _approve(owner, spender, currentAllowance - amount);\n            }\n        }\n    }\n\n    /**\n     * @dev Hook that is called before any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * will be transferred to `to`.\n     * - when `from` is zero, `amount` tokens will be minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n\n    /**\n     * @dev Hook that is called after any transfer of tokens. This includes\n     * minting and burning.\n     *\n     * Calling conditions:\n     *\n     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens\n     * has been transferred to `to`.\n     * - when `from` is zero, `amount` tokens have been minted for `to`.\n     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.\n     * - `from` and `to` are never both zero.\n     *\n     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].\n     */\n    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)\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 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    /**\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 `to`.\n     *\n     * Returns a boolean value indicating whether the operation succeeded.\n     *\n     * Emits a {Transfer} event.\n     */\n    function transfer(address to, 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 `from` to `to` 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(address from, address to, uint256 amount) external returns (bool);\n}\n"},"@openzeppelin/contracts/access/AccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IAccessControl.sol\";\nimport \"../utils/Context.sol\";\nimport \"../utils/Strings.sol\";\nimport \"../utils/introspection/ERC165.sol\";\n\n/**\n * @dev Contract module that allows children to implement role-based access\n * control mechanisms. This is a lightweight version that doesn't allow enumerating role\n * members except through off-chain means by accessing the contract event logs. Some\n * applications may benefit from on-chain enumerability, for those cases see\n * {AccessControlEnumerable}.\n *\n * Roles are referred to by their `bytes32` identifier. These should be exposed\n * in the external API and be unique. The best way to achieve this is by\n * using `public constant` hash digests:\n *\n * ```solidity\n * bytes32 public constant MY_ROLE = keccak256(\"MY_ROLE\");\n * ```\n *\n * Roles can be used to represent a set of permissions. To restrict access to a\n * function call, use {hasRole}:\n *\n * ```solidity\n * function foo() public {\n *     require(hasRole(MY_ROLE, msg.sender));\n *     ...\n * }\n * ```\n *\n * Roles can be granted and revoked dynamically via the {grantRole} and\n * {revokeRole} functions. Each role has an associated admin role, and only\n * accounts that have a role's admin role can call {grantRole} and {revokeRole}.\n *\n * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means\n * that only accounts with this role will be able to grant or revoke other\n * roles. More complex role relationships can be created by using\n * {_setRoleAdmin}.\n *\n * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to\n * grant and revoke this role. Extra precautions should be taken to secure\n * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}\n * to enforce additional security measures for this role.\n */\nabstract contract AccessControl is Context, IAccessControl, ERC165 {\n    struct RoleData {\n        mapping(address => bool) members;\n        bytes32 adminRole;\n    }\n\n    mapping(bytes32 => RoleData) private _roles;\n\n    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;\n\n    /**\n     * @dev Modifier that checks that an account has a specific role. Reverts\n     * with a standardized message including the required role.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     *\n     * _Available since v4.1._\n     */\n    modifier onlyRole(bytes32 role) {\n        _checkRole(role);\n        _;\n    }\n\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);\n    }\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) public view virtual override returns (bool) {\n        return _roles[role].members[account];\n    }\n\n    /**\n     * @dev Revert with a standard message if `_msgSender()` is missing `role`.\n     * Overriding this function changes the behavior of the {onlyRole} modifier.\n     *\n     * Format of the revert message is described in {_checkRole}.\n     *\n     * _Available since v4.6._\n     */\n    function _checkRole(bytes32 role) internal view virtual {\n        _checkRole(role, _msgSender());\n    }\n\n    /**\n     * @dev Revert with a standard message if `account` is missing `role`.\n     *\n     * The format of the revert reason is given by the following regular expression:\n     *\n     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/\n     */\n    function _checkRole(bytes32 role, address account) internal view virtual {\n        if (!hasRole(role, account)) {\n            revert(\n                string(\n                    abi.encodePacked(\n                        \"AccessControl: account \",\n                        Strings.toHexString(account),\n                        \" is missing role \",\n                        Strings.toHexString(uint256(role), 32)\n                    )\n                )\n            );\n        }\n    }\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {\n        return _roles[role].adminRole;\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been revoked `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function renounceRole(bytes32 role, address account) public virtual override {\n        require(account == _msgSender(), \"AccessControl: can only renounce roles for self\");\n\n        _revokeRole(role, account);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event. Note that unlike {grantRole}, this function doesn't perform any\n     * checks on the calling account.\n     *\n     * May emit a {RoleGranted} event.\n     *\n     * [WARNING]\n     * ====\n     * This function should only be called from the constructor when setting\n     * up the initial roles for the system.\n     *\n     * Using this function in any other way is effectively circumventing the admin\n     * system imposed by {AccessControl}.\n     * ====\n     *\n     * NOTE: This function is deprecated in favor of {_grantRole}.\n     */\n    function _setupRole(bytes32 role, address account) internal virtual {\n        _grantRole(role, account);\n    }\n\n    /**\n     * @dev Sets `adminRole` as ``role``'s admin role.\n     *\n     * Emits a {RoleAdminChanged} event.\n     */\n    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {\n        bytes32 previousAdminRole = getRoleAdmin(role);\n        _roles[role].adminRole = adminRole;\n        emit RoleAdminChanged(role, previousAdminRole, adminRole);\n    }\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleGranted} event.\n     */\n    function _grantRole(bytes32 role, address account) internal virtual {\n        if (!hasRole(role, account)) {\n            _roles[role].members[account] = true;\n            emit RoleGranted(role, account, _msgSender());\n        }\n    }\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * Internal function without access restriction.\n     *\n     * May emit a {RoleRevoked} event.\n     */\n    function _revokeRole(bytes32 role, address account) internal virtual {\n        if (hasRole(role, account)) {\n            _roles[role].members[account] = false;\n            emit RoleRevoked(role, account, _msgSender());\n        }\n    }\n}\n"},"@openzeppelin/contracts/access/IAccessControl.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev External interface of AccessControl declared to support ERC165 detection.\n */\ninterface IAccessControl {\n    /**\n     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`\n     *\n     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite\n     * {RoleAdminChanged} not being emitted signaling this.\n     *\n     * _Available since v3.1._\n     */\n    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);\n\n    /**\n     * @dev Emitted when `account` is granted `role`.\n     *\n     * `sender` is the account that originated the contract call, an admin role\n     * bearer except when using {AccessControl-_setupRole}.\n     */\n    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Emitted when `account` is revoked `role`.\n     *\n     * `sender` is the account that originated the contract call:\n     *   - if using `revokeRole`, it is the admin role bearer\n     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)\n     */\n    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);\n\n    /**\n     * @dev Returns `true` if `account` has been granted `role`.\n     */\n    function hasRole(bytes32 role, address account) external view returns (bool);\n\n    /**\n     * @dev Returns the admin role that controls `role`. See {grantRole} and\n     * {revokeRole}.\n     *\n     * To change a role's admin, use {AccessControl-_setRoleAdmin}.\n     */\n    function getRoleAdmin(bytes32 role) external view returns (bytes32);\n\n    /**\n     * @dev Grants `role` to `account`.\n     *\n     * If `account` had not been already granted `role`, emits a {RoleGranted}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function grantRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from `account`.\n     *\n     * If `account` had been granted `role`, emits a {RoleRevoked} event.\n     *\n     * Requirements:\n     *\n     * - the caller must have ``role``'s admin role.\n     */\n    function revokeRole(bytes32 role, address account) external;\n\n    /**\n     * @dev Revokes `role` from the calling account.\n     *\n     * Roles are often managed via {grantRole} and {revokeRole}: this function's\n     * purpose is to provide a mechanism for accounts to lose their privileges\n     * if they are compromised (such as when a trusted device is misplaced).\n     *\n     * If the calling account had been granted `role`, emits a {RoleRevoked}\n     * event.\n     *\n     * Requirements:\n     *\n     * - the caller must be `account`.\n     */\n    function renounceRole(bytes32 role, address account) external;\n}\n"},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)\n\npragma solidity ^0.8.0;\n\n/**\n * @dev Standard signed math utilities missing in the Solidity language.\n */\nlibrary SignedMath {\n    /**\n     * @dev Returns the largest of two signed numbers.\n     */\n    function max(int256 a, int256 b) internal pure returns (int256) {\n        return a > b ? a : b;\n    }\n\n    /**\n     * @dev Returns the smallest of two signed numbers.\n     */\n    function min(int256 a, int256 b) internal pure returns (int256) {\n        return a < b ? a : b;\n    }\n\n    /**\n     * @dev Returns the average of two signed numbers without overflow.\n     * The result is rounded towards zero.\n     */\n    function average(int256 a, int256 b) internal pure returns (int256) {\n        // Formula from the book \"Hacker's Delight\"\n        int256 x = (a & b) + ((a ^ b) >> 1);\n        return x + (int256(uint256(x) >> 255) & (a ^ b));\n    }\n\n    /**\n     * @dev Returns the absolute unsigned value of a signed value.\n     */\n    function abs(int256 n) internal pure returns (uint256) {\n        unchecked {\n            // must be unchecked in order to support `n = type(int256).min`\n            return uint256(n >= 0 ? n : -n);\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)\n\npragma solidity ^0.8.0;\n\nimport \"./IERC165.sol\";\n\n/**\n * @dev Implementation of the {IERC165} interface.\n *\n * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check\n * for the additional interface id that will be supported. For example:\n *\n * ```solidity\n * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);\n * }\n * ```\n *\n * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.\n */\nabstract contract ERC165 is IERC165 {\n    /**\n     * @dev See {IERC165-supportsInterface}.\n     */\n    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {\n        return interfaceId == type(IERC165).interfaceId;\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/token/ERC20/extensions/ERC20Capped.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/ERC20Capped.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../ERC20.sol\";\n\n/**\n * @dev Extension of {ERC20} that adds a cap to the supply of tokens.\n */\nabstract contract ERC20Capped is ERC20 {\n    uint256 private immutable _cap;\n\n    /**\n     * @dev Sets the value of the `cap`. This value is immutable, it can only be\n     * set once during construction.\n     */\n    constructor(uint256 cap_) {\n        require(cap_ > 0, \"ERC20Capped: cap is 0\");\n        _cap = cap_;\n    }\n\n    /**\n     * @dev Returns the cap on the token's total supply.\n     */\n    function cap() public view virtual returns (uint256) {\n        return _cap;\n    }\n\n    /**\n     * @dev See {ERC20-_mint}.\n     */\n    function _mint(address account, uint256 amount) internal virtual override {\n        require(ERC20.totalSupply() + amount <= cap(), \"ERC20Capped: cap exceeded\");\n        super._mint(account, amount);\n    }\n}\n"},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)\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"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"bytecodeHash":"none"},"libraries":{},"optimizer":{"runs":1000000,"enabled":true},"evmVersion":"paris","remappings":[]}},"stdJsonOutput":{"sources":{"contracts/bas/BAS.sol":{"id":13},"@openzeppelin/contracts/utils/Context.sol":{"id":7},"@openzeppelin/contracts/utils/Strings.sol":{"id":8},"@openzeppelin/contracts/utils/math/Math.sol":{"id":11},"@openzeppelin/contracts/security/Pausable.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":3},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":4},"@openzeppelin/contracts/access/AccessControl.sol":{"id":0},"@openzeppelin/contracts/access/IAccessControl.sol":{"id":1},"@openzeppelin/contracts/utils/math/SignedMath.sol":{"id":12},"@openzeppelin/contracts/utils/introspection/ERC165.sol":{"id":9},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"id":10},"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol":{"id":5},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":6}},"contracts":{"contracts/bas/BAS.sol":{"BASToken":{"abi":[{"type":"constructor","inputs":[{"name":"name","type":"string","internalType":"string"},{"name":"symbol","type":"string","internalType":"string"},{"name":"cap","type":"uint256","internalType":"uint256"},{"name":"admin","type":"address","internalType":"address"},{"name":"pauser","type":"address","internalType":"address"}],"stateMutability":"nonpayable"},{"name":"Approval","type":"event","inputs":[{"name":"owner","type":"address","indexed":true,"internalType":"address"},{"name":"spender","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"ERC20Recovered","type":"event","inputs":[{"name":"token","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"amount","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Paused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"RoleAdminChanged","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"previousAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"newAdminRole","type":"bytes32","indexed":true,"internalType":"bytes32"}],"anonymous":false},{"name":"RoleGranted","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"RoleRevoked","type":"event","inputs":[{"name":"role","type":"bytes32","indexed":true,"internalType":"bytes32"},{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"sender","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"Transfer","type":"event","inputs":[{"name":"from","type":"address","indexed":true,"internalType":"address"},{"name":"to","type":"address","indexed":true,"internalType":"address"},{"name":"value","type":"uint256","indexed":false,"internalType":"uint256"}],"anonymous":false},{"name":"Unpaused","type":"event","inputs":[{"name":"account","type":"address","indexed":false,"internalType":"address"}],"anonymous":false},{"name":"WhitelistUpdated","type":"event","inputs":[{"name":"account","type":"address","indexed":true,"internalType":"address"},{"name":"isWhitelisted","type":"bool","indexed":false,"internalType":"bool"}],"anonymous":false},{"name":"DEFAULT_ADMIN_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"MINTER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"PAUSER_ROLE","type":"function","inputs":[],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"addToWhitelist","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"allowance","type":"function","inputs":[{"name":"owner","type":"address","internalType":"address"},{"name":"spender","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"approve","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"balanceOf","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"cap","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"decimals","type":"function","inputs":[],"outputs":[{"name":"","type":"uint8","internalType":"uint8"}],"stateMutability":"view"},{"name":"decreaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"subtractedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"getRoleAdmin","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"}],"outputs":[{"name":"","type":"bytes32","internalType":"bytes32"}],"stateMutability":"view"},{"name":"grantRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"hasRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"increaseAllowance","type":"function","inputs":[{"name":"spender","type":"address","internalType":"address"},{"name":"addedValue","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"isWhitelisted","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"mint","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"pause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"paused","type":"function","inputs":[],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"recoverERC20","type":"function","inputs":[{"name":"token","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"removeFromWhitelist","type":"function","inputs":[{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"renounceRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"revokeRole","type":"function","inputs":[{"name":"role","type":"bytes32","internalType":"bytes32"},{"name":"account","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"setMinter","type":"function","inputs":[{"name":"minter","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"supportsInterface","type":"function","inputs":[{"name":"interfaceId","type":"bytes4","internalType":"bytes4"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"view"},{"name":"symbol","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"totalSupply","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transfer","type":"function","inputs":[{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"transferFrom","type":"function","inputs":[{"name":"from","type":"address","internalType":"address"},{"name":"to","type":"address","internalType":"address"},{"name":"amount","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"bool","internalType":"bool"}],"stateMutability":"nonpayable"},{"name":"unpause","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.26+commit.8a97fa7a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint256\",\"name\":\"cap\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"admin\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"pauser\",\"type\":\"address\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"ERC20Recovered\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Paused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"previousAdminRole\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"newAdminRole\",\"type\":\"bytes32\"}],\"name\":\"RoleAdminChanged\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleGranted\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"}],\"name\":\"RoleRevoked\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"Unpaused\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"isWhitelisted\",\"type\":\"bool\"}],\"name\":\"WhitelistUpdated\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"DEFAULT_ADMIN_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"MINTER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"PAUSER_ROLE\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addToWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"cap\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"}],\"name\":\"getRoleAdmin\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"grantRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"hasRole\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isWhitelisted\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"pause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"paused\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"recoverERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"removeFromWhitelist\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"renounceRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes32\",\"name\":\"role\",\"type\":\"bytes32\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"revokeRole\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"minter\",\"type\":\"address\"}],\"name\":\"setMinter\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"unpause\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}],\"devdoc\":{\"events\":{\"Approval(address,address,uint256)\":{\"details\":\"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance.\"},\"ERC20Recovered(address,address,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to recover.\",\"to\":\"The address to receive the recovered tokens.\",\"token\":\"The address of the ERC20 token contract.\"}},\"Paused(address)\":{\"details\":\"Emitted when the pause is triggered by `account`.\"},\"RoleAdminChanged(bytes32,bytes32,bytes32)\":{\"details\":\"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._\"},\"RoleGranted(bytes32,address,address)\":{\"details\":\"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}.\"},\"RoleRevoked(bytes32,address,address)\":{\"details\":\"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"},\"Unpaused(address)\":{\"details\":\"Emitted when the pause is lifted by `account`.\"}},\"kind\":\"dev\",\"methods\":{\"addToWhitelist(address)\":{\"params\":{\"account\":\"The address to add to the whitelist.\"}},\"allowance(address,address)\":{\"details\":\"See {IERC20-allowance}.\"},\"approve(address,uint256)\":{\"details\":\"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address.\"},\"balanceOf(address)\":{\"details\":\"See {IERC20-balanceOf}.\"},\"cap()\":{\"details\":\"Returns the cap on the token's total supply.\"},\"constructor\":{\"params\":{\"admin\":\"The address to be set as the default admin of the token.\",\"cap\":\"The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).\",\"name\":\"The name of the token.\",\"pauser\":\"The address to be set as the pauser\",\"symbol\":\"The symbol of the token.\"}},\"decimals()\":{\"details\":\"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 default value returned by this function, unless it's 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}.\"},\"decreaseAllowance(address,uint256)\":{\"details\":\"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`.\"},\"getRoleAdmin(bytes32)\":{\"details\":\"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}.\"},\"grantRole(bytes32,address)\":{\"details\":\"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event.\"},\"hasRole(bytes32,address)\":{\"details\":\"Returns `true` if `account` has been granted `role`.\"},\"increaseAllowance(address,uint256)\":{\"details\":\"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.\"},\"isWhitelisted(address)\":{\"params\":{\"account\":\"The address to check.\"}},\"mint(address,uint256)\":{\"params\":{\"amount\":\"The amount of tokens to mint.\",\"to\":\"The address that will receive the minted tokens.\"}},\"name()\":{\"details\":\"Returns the name of the token.\"},\"paused()\":{\"details\":\"Returns true if the contract is paused, and false otherwise.\"},\"removeFromWhitelist(address)\":{\"params\":{\"account\":\"The address to remove from the whitelist.\"}},\"renounceRole(bytes32,address)\":{\"details\":\"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event.\"},\"revokeRole(bytes32,address)\":{\"details\":\"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event.\"},\"setMinter(address)\":{\"params\":{\"minter\":\"The address to be granted the MINTER_ROLE.\"}},\"supportsInterface(bytes4)\":{\"details\":\"See {IERC165-supportsInterface}.\"},\"symbol()\":{\"details\":\"Returns the symbol of the token, usually a shorter version of the name.\"},\"totalSupply()\":{\"details\":\"See {IERC20-totalSupply}.\"},\"transfer(address,uint256)\":{\"details\":\"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`.\"},\"transferFrom(address,address,uint256)\":{\"details\":\"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`.\"}},\"title\":\"BAS Token Contract\",\"version\":1},\"userdoc\":{\"events\":{\"ERC20Recovered(address,address,uint256)\":{\"notice\":\"Recover ERC20 tokens mistakenly sent to this contract.\"}},\"kind\":\"user\",\"methods\":{\"addToWhitelist(address)\":{\"notice\":\"Adds an address to the whitelist.\"},\"constructor\":{\"notice\":\"Initializes the contract.\"},\"isWhitelisted(address)\":{\"notice\":\"Returns true if the account is whitelisted.\"},\"mint(address,uint256)\":{\"notice\":\"Allows the minter to mint new tokens, up to the cap.\"},\"pause()\":{\"notice\":\"Allows the pause controller address to pause all token transfers for non-whitelisted addresses.\"},\"removeFromWhitelist(address)\":{\"notice\":\"Removes an address from the whitelist.\"},\"setMinter(address)\":{\"notice\":\"Set the minter address by granting MINTER_ROLE to the specified address.\"},\"unpause()\":{\"notice\":\"Allows the pause controller address to unpause the token transfers.\"}},\"notice\":\"Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.\",\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/bas/BAS.sol\":\"BASToken\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":1000000},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/access/AccessControl.sol\":{\"keccak256\":\"0x0dd6e52cb394d7f5abe5dca2d4908a6be40417914720932de757de34a99ab87f\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://dc117ce50ea746cab6b97ed1a1facee17a715ae0cb95d67b943dacbaf15176fb\",\"dweb:/ipfs/QmYRZ2UGNYwsHwfNu7Wjr8L2j1LBZ1mKv6NvbwgterYMXc\"]},\"@openzeppelin/contracts/access/IAccessControl.sol\":{\"keccak256\":\"0x59ce320a585d7e1f163cd70390a0ef2ff9cec832e2aa544293a00692465a7a57\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bb2c137c343ef0c4c7ce7b18c1d108afdc9d315a04e48307288d2d05adcbde3a\",\"dweb:/ipfs/QmUxhrAQM3MM3FF5j7AtcXLXguWCJBHJ14BRdVtuoQc8Fh\"]},\"@openzeppelin/contracts/security/Pausable.sol\":{\"keccak256\":\"0x0849d93b16c9940beb286a7864ed02724b248b93e0d80ef6355af5ef15c64773\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://4ddabb16009cd17eaca3143feadf450ac13e72919ebe2ca50e00f61cb78bc004\",\"dweb:/ipfs/QmSPwPxX7d6TTWakN5jy5wsaGkS1y9TW8fuhGSraMkLk2B\"]},\"@openzeppelin/contracts/token/ERC20/ERC20.sol\":{\"keccak256\":\"0xa56ca923f70c1748830700250b19c61b70db9a683516dc5e216694a50445d99c\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cac938788bc4be12101e59d45588b4e059579f4e61062e1cda8d6b06c0191b15\",\"dweb:/ipfs/QmV2JKCyjTVH3rkWNrfdJRhAT7tZ3usAN2XcnD4h53Mvih\"]},\"@openzeppelin/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0x287b55befed2961a7eabd7d7b1b2839cbca8a5b80ef8dcbb25ed3d4c2002c305\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://bd39944e8fc06be6dbe2dd1d8449b5336e23c6a7ba3e8e9ae5ae0f37f35283f5\",\"dweb:/ipfs/QmPV3FGYjVwvKSgAXKUN3r9T9GwniZz83CxBpM7vyj2G53\"]},\"@openzeppelin/contracts/token/ERC20/extensions/ERC20Capped.sol\":{\"keccak256\":\"0x3fe04ed1daf0f12454333fde982a25b103860d8a010dd5d8479b83ebf1dfb788\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8322152771e94c9e28a3bd9e7c9d5dd4fdd00ae214f95915962a6638d8dfc7d6\",\"dweb:/ipfs/QmaXJvF3UjRHacx3nPgt94DwAuXCkEoz6fS7MLr2jbuJyW\"]},\"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol\":{\"keccak256\":\"0x8de418a5503946cabe331f35fe242d3201a73f67f77aaeb7110acb1f30423aca\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://5a376d3dda2cb70536c0a45c208b29b34ac560c4cb4f513a42079f96ba47d2dd\",\"dweb:/ipfs/QmZQg6gn1sUpM8wHzwNvSnihumUCAhxD119MpXeKp8B9s8\"]},\"@openzeppelin/contracts/utils/Context.sol\":{\"keccak256\":\"0xa92e4fa126feb6907daa0513ddd816b2eb91f30a808de54f63c17d0e162c3439\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://a367861093b74443b137564d3f3c472f70bcf114739e62059c939f25e315706c\",\"dweb:/ipfs/Qmd7JMpcxD9RuQjK3uM3EzJUgSqdN8vzp8eytEiuwxQJ6h\"]},\"@openzeppelin/contracts/utils/Strings.sol\":{\"keccak256\":\"0x3088eb2868e8d13d89d16670b5f8612c4ab9ff8956272837d8e90106c59c14a0\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://b81d9ff6559ea5c47fc573e17ece6d9ba5d6839e213e6ebc3b4c5c8fe4199d7f\",\"dweb:/ipfs/QmPCW1bFisUzJkyjroY3yipwfism9RRCigCcK1hbXtVM8n\"]},\"@openzeppelin/contracts/utils/introspection/ERC165.sol\":{\"keccak256\":\"0xd10975de010d89fd1c78dc5e8a9a7e7f496198085c151648f20cba166b32582b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fb0048dee081f6fffa5f74afc3fb328483c2a30504e94a0ddd2a5114d731ec4d\",\"dweb:/ipfs/QmZptt1nmYoA5SgjwnSgWqgUSDgm4q52Yos3xhnMv3MV43\"]},\"@openzeppelin/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x447a5f3ddc18419d41ff92b3773fb86471b1db25773e07f877f548918a185bf1\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://be161e54f24e5c6fae81a12db1a8ae87bc5ae1b0ddc805d82a1440a68455088f\",\"dweb:/ipfs/QmP7C3CHdY9urF4dEMb9wmsp1wMxHF6nhA2yQE5SKiPAdy\"]},\"@openzeppelin/contracts/utils/math/Math.sol\":{\"keccak256\":\"0xe4455ac1eb7fc497bb7402579e7b4d64d928b846fce7d2b6fde06d366f21c2b3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://cc8841b3cd48ad125e2f46323c8bad3aa0e88e399ec62acb9e57efa7e7c8058c\",\"dweb:/ipfs/QmSqE4mXHA2BXW58deDbXE8MTcsL5JSKNDbm23sVQxRLPS\"]},\"@openzeppelin/contracts/utils/math/SignedMath.sol\":{\"keccak256\":\"0xf92515413956f529d95977adc9b0567d583c6203fc31ab1c23824c35187e3ddc\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://c50fcc459e49a9858b6d8ad5f911295cb7c9ab57567845a250bf0153f84a95c7\",\"dweb:/ipfs/QmcEW85JRzvDkQggxiBBLVAasXWdkhEysqypj9EaB6H2g6\"]},\"contracts/bas/BAS.sol\":{\"keccak256\":\"0x34abdd99c82eb94d458fdec8bb651f3e92b6dffd3ff21a237b5b6f72d01dba6d\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1eab537561884c9d42e028f1970e52c8bdc3b4eee3893fed516e5758052f84ae\",\"dweb:/ipfs/QmbrMsK8QPiczfFXPynRQNGbappNfgFGHjCpgk39WqJFzp\"]}},\"version\":1}","userdoc":{"kind":"user","events":{"ERC20Recovered(address,address,uint256)":{"notice":"Recover ERC20 tokens mistakenly sent to this contract."}},"notice":"Implements an ERC20 token with a cap, pausability, ownership, and a whitelist feature.","methods":{"pause()":{"notice":"Allows the pause controller address to pause all token transfers for non-whitelisted addresses."},"unpause()":{"notice":"Allows the pause controller address to unpause the token transfers."},"constructor":{"notice":"Initializes the contract."},"setMinter(address)":{"notice":"Set the minter address by granting MINTER_ROLE to the specified address."},"mint(address,uint256)":{"notice":"Allows the minter to mint new tokens, up to the cap."},"isWhitelisted(address)":{"notice":"Returns true if the account is whitelisted."},"addToWhitelist(address)":{"notice":"Adds an address to the whitelist."},"removeFromWhitelist(address)":{"notice":"Removes an address from the whitelist."}},"version":1},"devdoc":{"kind":"dev","title":"BAS Token Contract","events":{"Paused(address)":{"details":"Emitted when the pause is triggered by `account`."},"Unpaused(address)":{"details":"Emitted when the pause is lifted by `account`."},"Approval(address,address,uint256)":{"details":"Emitted when the allowance of a `spender` for an `owner` is set by a call to {approve}. `value` is the new allowance."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."},"RoleGranted(bytes32,address,address)":{"details":"Emitted when `account` is granted `role`. `sender` is the account that originated the contract call, an admin role bearer except when using {AccessControl-_setupRole}."},"RoleRevoked(bytes32,address,address)":{"details":"Emitted when `account` is revoked `role`. `sender` is the account that originated the contract call:   - if using `revokeRole`, it is the admin role bearer   - if using `renounceRole`, it is the role bearer (i.e. `account`)"},"ERC20Recovered(address,address,uint256)":{"params":{"to":"The address to receive the recovered tokens.","token":"The address of the ERC20 token contract.","amount":"The amount of tokens to recover."}},"RoleAdminChanged(bytes32,bytes32,bytes32)":{"details":"Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole` `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite {RoleAdminChanged} not being emitted signaling this. _Available since v3.1._"}},"methods":{"cap()":{"details":"Returns the cap on the token's total supply."},"name()":{"details":"Returns the name of the token."},"paused()":{"details":"Returns true if the contract is paused, and false otherwise."},"symbol()":{"details":"Returns the symbol of the token, usually a shorter version of the name."},"decimals()":{"details":"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 default value returned by this function, unless it's 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}."},"constructor":{"params":{"cap":"The maximum total supply of the token (e.g., for 1 million tokens with 18 decimals, pass 1000000 * 10**18).","name":"The name of the token.","admin":"The address to be set as the default admin of the token.","pauser":"The address to be set as the pauser","symbol":"The symbol of the token."}},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"setMinter(address)":{"params":{"minter":"The address to be granted the MINTER_ROLE."}},"getRoleAdmin(bytes32)":{"details":"Returns the admin role that controls `role`. See {grantRole} and {revokeRole}. To change a role's admin, use {_setRoleAdmin}."},"mint(address,uint256)":{"params":{"to":"The address that will receive the minted tokens.","amount":"The amount of tokens to mint."}},"isWhitelisted(address)":{"params":{"account":"The address to check."}},"addToWhitelist(address)":{"params":{"account":"The address to add to the whitelist."}},"approve(address,uint256)":{"details":"See {IERC20-approve}. NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on `transferFrom`. This is semantically equivalent to an infinite approval. Requirements: - `spender` cannot be the zero address."},"hasRole(bytes32,address)":{"details":"Returns `true` if `account` has been granted `role`."},"supportsInterface(bytes4)":{"details":"See {IERC165-supportsInterface}."},"transfer(address,uint256)":{"details":"See {IERC20-transfer}. Requirements: - `to` cannot be the zero address. - the caller must have a balance of at least `amount`."},"allowance(address,address)":{"details":"See {IERC20-allowance}."},"grantRole(bytes32,address)":{"details":"Grants `role` to `account`. If `account` had not been already granted `role`, emits a {RoleGranted} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleGranted} event."},"revokeRole(bytes32,address)":{"details":"Revokes `role` from `account`. If `account` had been granted `role`, emits a {RoleRevoked} event. Requirements: - the caller must have ``role``'s admin role. May emit a {RoleRevoked} event."},"removeFromWhitelist(address)":{"params":{"account":"The address to remove from the whitelist."}},"renounceRole(bytes32,address)":{"details":"Revokes `role` from the calling account. Roles are often managed via {grantRole} and {revokeRole}: this function's purpose is to provide a mechanism for accounts to lose their privileges if they are compromised (such as when a trusted device is misplaced). If the calling account had been revoked `role`, emits a {RoleRevoked} event. Requirements: - the caller must be `account`. May emit a {RoleRevoked} event."},"decreaseAllowance(address,uint256)":{"details":"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`."},"increaseAllowance(address,uint256)":{"details":"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."},"transferFrom(address,address,uint256)":{"details":"See {IERC20-transferFrom}. Emits an {Approval} event indicating the updated allowance. This is not required by the EIP. See the note at the beginning of {ERC20}. NOTE: Does not update the allowance if the current allowance is the maximum `uint256`. Requirements: - `from` and `to` cannot be the zero address. - `from` must have a balance of at least `amount`. - the caller must have allowance for ``from``'s tokens of at least `amount`."}},"version":1},"storageLayout":{"types":{"t_bool":{"label":"bool","encoding":"inplace","numberOfBytes":"1"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_bytes32":{"label":"bytes32","encoding":"inplace","numberOfBytes":"32"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_bool)":{"key":"t_address","label":"mapping(address => bool)","value":"t_bool","encoding":"mapping","numberOfBytes":"32"},"t_struct(RoleData)19_storage":{"label":"struct AccessControl.RoleData","members":[{"slot":"0","type":"t_mapping(t_address,t_bool)","astId":16,"label":"members","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"1","type":"t_bytes32","astId":18,"label":"adminRole","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"}],"encoding":"inplace","numberOfBytes":"64"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_bytes32,t_struct(RoleData)19_storage)":{"key":"t_bytes32","label":"mapping(bytes32 => struct AccessControl.RoleData)","value":"t_struct(RoleData)19_storage","encoding":"mapping","numberOfBytes":"32"},"t_mapping(t_address,t_mapping(t_address,t_uint256))":{"key":"t_address","label":"mapping(address => mapping(address => uint256))","value":"t_mapping(t_address,t_uint256)","encoding":"mapping","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_bool","astId":406,"label":"_paused","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"1","type":"t_mapping(t_address,t_uint256)","astId":512,"label":"_balances","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":518,"label":"_allowances","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"3","type":"t_uint256","astId":520,"label":"_totalSupply","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"4","type":"t_string_storage","astId":522,"label":"_name","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"5","type":"t_string_storage","astId":524,"label":"_symbol","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"6","type":"t_mapping(t_bytes32,t_struct(RoleData)19_storage)","astId":24,"label":"_roles","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"},{"slot":"7","type":"t_mapping(t_address,t_bool)","astId":2549,"label":"_isWhitelisted","offset":0,"contract":"contracts/bas/BAS.sol:BASToken"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"508:4405:13:-:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;:::i;:::-;;;;;;;;;;;;;:::i;:::-;;;;:::i;:::-;-1:-1:-1;508:4405:13;;-1:-1:-1;;508:4405:13;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;2046:13:3;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;2046:13:3;508:4405:13;;;;-1:-1:-1;;;;;508:4405:13;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;2069:17:3;508:4405:13;;494:8:5;;508:4405:13;;;538:11:5;-1:-1:-1;;;;;508:4405:13;;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;;7669:23:0;7665:149;;508:4405:13;-1:-1:-1;;;;;;508:4405:13;;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;;7669:23:0;7665:149;;508:4405:13;-1:-1:-1;;;;;;;;;;;;;508:4405:13;;;3130:6:0;508:4405:13;;4604:22:0;508:4405:13;;;;;;;;;679:24;;;7360:52:0;;-1:-1:-1;7360:52:0;-1:-1:-1;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;2274:20:2;508:4405:13;;;734:10:7;508:4405:13;;2274:20:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;508:4405:13;;;2046:13:3;508:4405:13;;;;;;;;-1:-1:-1;;;508:4405:13;;;;;;;7665:149:0;-1:-1:-1;;;;;508:4405:13;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;-1:-1:-1;;508:4405:13;;;;;734:10:7;;508:4405:13;-1:-1:-1;;;;;;;;;;;679:24:13;-1:-1:-1;;;;;;;;;;;7763:40:0;-1:-1:-1;7763:40:0;7665:149;;;;-1:-1:-1;;;;;508:4405:13;-1:-1:-1;508:4405:13;;;-1:-1:-1;;;;;;;;;;;508:4405:13;;;;;;;-1:-1:-1;;508:4405:13;;;;;734:10:7;;508:4405:13;-1:-1:-1;;;;;;;;;;;;;7763:40:0;7665:149;;;508:4405:13;;;-1:-1:-1;;;508:4405:13;;;2046:13:3;508:4405:13;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;2069:17:3;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:17:3;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;2069:17:3;508:4405:13;;;;;;;;;;;;2069:17:3;508:4405:13;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;-1:-1:-1;508:4405:13;;2046:13:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;2046:13:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;2046:13:3;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;;;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;2046:13:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2046:13:3;-1:-1:-1;508:4405:13;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;;508:4405:13;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;;;:::o;:::-;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;;;-1:-1:-1;;508:4405:13;;;;:::i;:::-;;;;;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;-1:-1:-1;508:4405:13;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;508:4405:13;;;;;;:::o","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"508:4405:13:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;2185:20;;508:4405;;-1:-1:-1;508:4405:13;;;;;;;;;;;;7669:23:0;7665:149;;508:4405:13;;;7665:149:0;-1:-1:-1;508:4405:13;;;;;;;;;;;;;7740:4:0;508:4405:13;;;734:10:7;;508:4405:13;610:24;;7763:40:0;;-1:-1:-1;7763:40:0;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;679:24;508:4405;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;3035:21;;508:4405;;;;;3104:14;508:4405;;;;;3130:4;508:4405;;;;;;;3149:31;508:4405;;;3130:4;508:4405;;3149:31;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;:::i;:::-;;;;;4102:11:3;508:4405:13;;;4102:27:3;508:4405:13;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;5486:7:0;508:4405:13;;;;:::i;:::-;5438:18:0;2642:4;5438:18;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;5438:18;2642:4;:::i;:::-;5486:7;:::i;:::-;508:4405:13;;;;;;;;;;;;;;;;;610:24;508:4405;;;;;;;;;;;;;;;3894:6:3;508:4405:13;;:::i;:::-;;;734:10:7;;3894:6:3;:::i;:::-;508:4405:13;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;734:10:7;;508:4405:13;;4102:11:3;508:4405:13;;;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;6792:35:3;;;;508:4405:13;;6928:34:3;508:4405:13;;734:10:7;;6928:34:3;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;2457:7:3;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:3;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;3130:6:0;508:4405:13;;;3130:29:0;508:4405:13;-1:-1:-1;508:4405:13;;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;:::i;:::-;508:4405:13;3422:21;;508:4405;;;;;3494:14;508:4405;;;;;;;;;;;3540:32;508:4405;;;;;;3540:32;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2642:4:0;;:::i;:::-;508:4405:13;;;;;;;;2255:4:2;508:4405:13;;;;;2274:20:2;508:4405:13;;;734:10:7;508:4405:13;;2274:20:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;3519:9:3;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;610:24;508:4405;;3130:6:0;508:4405:13;;;;;;734:10:7;508:4405:13;;;;;;;;;;;3931:23:0;3927:390;;3342:12:3;508:4405:13;861:28:5;;;;;:::i;:::-;705:4;-1:-1:-1;508:4405:13;;;;8603:21:3;;;508:4405:13;;;;;;3803:234;;508:4405;;8731:22:3;;;;8952:37;8731:22;;:::i;:::-;3342:12;508:4405:13;;;;;;;;;;;;;;;;;;;;;8952:37:3;508:4405:13;;3803:234;508:4405;;;;8731:22:3;508:4405:13;;8952:37:3;508:4405:13;;3903:14;508:4405;;;;;;;;3903:42;;3803:234;;;;;;;;;;3903:42;508:4405;;;3903:14;508:4405;;3903:42;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3927:390:0;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;610:24:13;4214:38:0;:::i;:::-;508:4405:13;;;;4022:252:0;;;508:4405:13;;4022:252:0;;508:4405:13;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;4022:252:0;;;;;;;;;:::i;:::-;508:4405:13;;3970:336:0;;;;;;508:4405:13;3970:336:0;;;:::i;:::-;;;;508:4405:13;;;;;;;;;;;;2642:4:0;;:::i;:::-;508:4405:13;;;;;;;;;;;;2521:22:2;508:4405:13;;;734:10:7;508:4405:13;;2521:22:2;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2785:14;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;6021:38:3;508:4405:13;6021:38:3;508:4405:13;;;:::i;:::-;734:10:7;;508:4405:13;;4102:11:3;508:4405:13;;;;;;;;;;;;;;;;;6021:38:3;:::i;:::-;734:10:7;;6021:38:3;:::i;508:4405:13:-;;;;;;;;;;;;;;:::i;:::-;734:10:7;508:4405:13;;;6133:23:0;508:4405:13;;6237:7:0;508:4405:13;;;6237:7:0;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;705:4:5;508:4405:13;;;;;;;;;;;;;;;;;;3186:2:3;508:4405:13;;;;;;;;;;;;;;;;;;;:::i;:::-;5012:18:0;2642:4;5012:18;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;2642:4;508:4405:13;;;3130:6:0;508:4405:13;;;;;;;;;;;;;;;;;;7669:23:0;7665:149;;508:4405:13;;;7665:149:0;508:4405:13;;;3130:6:0;508:4405:13;;;;;;;;;;;;;;;7740:4:0;508:4405:13;;;;;;;;734:10:7;508:4405:13;;7763:40:0;;;;;7665:149;;508:4405:13;;;;;;;;;;;;;;;;;;;-1:-1:-1;508:4405:13;4604:6:0;508:4405:13;;4604:22:0;508:4405:13;-1:-1:-1;508:4405:13;4604:22:0;508:4405:13;4504:129:0;;508:4405:13;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;4102:11:3;508:4405:13;;;;;;734:10:7;508:4405:13;;;;;;;11244:37:3;11264:17;11244:37;;11240:243;;508:4405:13;5424:6:3;;;;:::i;11240:243::-;11305:26;;;508:4405:13;;11432:25:3;508:4405:13;5424:6:3;508:4405:13;;734:10:7;11432:25:3;;:::i;:::-;11240:243;;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3342:12:3;508:4405:13;;;;;;;;;;;;;;;;:::i;:::-;2642:4:0;;;;;:::i;:::-;508:4405:13;4563:16;;;508:4405;;;;4629:19;;;508:4405;;4699:10;;508:4405;;;;;4771:34;;;508:4405;4771:34;;508:4405;;;;;;;4771:34;;;;;;;;;;;;;;;;508:4405;;;;;;4871:33;508:4405;;;;;;4871:33;508:4405;;;;;;;;;;;;;;;;;;;;4771:34;508:4405;;;;4771:34;;;508:4405;4771:34;;508:4405;4771:34;;;;;;508:4405;4771:34;;;:::i;:::-;;;508:4405;;;;;;;;;;;;4771:34;;;508:4405;;;;4771:34;;;-1:-1:-1;4771:34:13;;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4606:6:3;508:4405:13;;:::i;:::-;;;734:10:7;;4606:6:3;:::i;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1;508:4405:13;;;;;;;-1:-1:-1;508:4405:13;;-1:-1:-1;508:4405:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2840:47:0;;2855:32;2840:47;;:87;;;;;508:4405:13;;;;;;;2840:87:0;952:25:9;937:40;;;2840:87:0;;;508:4405:13;;;;;;;;;;;;;;;;-1:-1:-1;;508:4405:13;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;;;;;:::o;:::-;;;;;;;;;;10457:340:3;508:4405:13;;10558:19:3;;;508:4405:13;;;;10636:21:3;;;508:4405:13;;;10758:32:3;508:4405:13;;10575:1:3;508:4405:13;10707:11:3;508:4405:13;;;10575:1:3;508:4405:13;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;;;;;10758:32:3;10457:340::o;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3460:103:0;734:10:7;508:4405:13;;;;;;;;;;;;;3931:23:0;3927:390;;3460:103::o;3927:390::-;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;508:4405:13;4214:38:0;:::i;3460:103::-;734:10:7;-1:-1:-1;508:4405:13;;;;;;;;;;;;3931:23:0;3927:390;;3460:103::o;3927:390::-;3970:336;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4022:252:0;508:4405:13;4214:38:0;679:24:13;4214:38:0;:::i;3460:103::-;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;734:10:7;508:4405:13;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;3931:23:0;3927:390;;3460:103;:::o;3927:390::-;3970:336;734:10:7;4022:252:0;508:4405:13;4214:38:0;2497:52:8;734:10:7;2497:52:8;:::i;:::-;4214:38:0;;:::i;7456:788:3:-;508:4405:13;;7552:18:3;;;508:4405:13;;7552:18:3;508:4405:13;;;;7630:16:3;;;508:4405:13;;;7568:1:3;508:4405:13;;3803:234;;7456:788:3;508:4405:13;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;7568:1:3;508:4405:13;;7801:21:3;;;508:4405:13;;;8163:26:3;508:4405:13;;;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;;7568:1:3;508:4405:13;;;7568:1:3;508:4405:13;7768:9:3;508:4405:13;;;7568:1:3;508:4405:13;;;;;;;;;;;;8163:26:3;7456:788::o;508:4405:13:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;3803:234;508:4405;7568:1:3;508:4405:13;3903:14;508:4405;;;;7568:1:3;508:4405:13;;;3903:42;;;3803:234;7568:1:3;7552:18;;3967:28:13;;3803:234;508:4405;;;;3803:234;;;508:4405;;;;;;;;;;;;;;;;;;;;;;;3967:28;;;;;;3903:42;508:4405;;7568:1:3;508:4405:13;3903:14;508:4405;;;;7568:1:3;508:4405:13;;;3903:42;;508:4405;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7991:234:0;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;-1:-1:-1;508:4405:13;;;8070:149:0;;7991:234;;:::o;8070:149::-;508:4405:13;-1:-1:-1;508:4405:13;3130:6:0;508:4405:13;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;-1:-1:-1;508:4405:13;;;;;;;;734:10:7;508:4405:13;;8168:40:0;;-1:-1:-1;8168:40:0;;7991:234::o;508:4405:13:-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;1818:437:8;-1:-1:-1;508:4405:13;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;1975:15:8;;;508:4405:13;;;;;;;2000:15:8;508:4405:13;;;2000:15:8;-1:-1:-1;508:4405:13;-1:-1:-1;2058:5:8;508:4405:13;2058:5:8;;;;2170:10;;278:18;;1818:437;:::o;278:18::-;;508:4405:13;;278:18:8;;;508:4405:13;2141:1:8;278:18;;;508:4405:13;278:18:8;;;508:4405:13;278:18:8;508:4405:13;;;278:18:8;;2065:3;2105:11;;2113:3;2105:11;;2096:21;;;;;;508:4405:13;2096:21:8;;2084:33;;;;:::i;:::-;;2141:1;278:18;2065:3;508:4405:13;;;;;;2030:26:8;;;508:4405:13;;;;;;;2141:1:8;508:4405:13;;2096:21:8;508:4405:13;;;;;;2141:1:8;508:4405:13;;;;;;;;;;;;;;;;;;;;;;1818:437:8;-1:-1:-1;508:4405:13;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;1975:15:8;;;508:4405:13;;;;;;;2000:15:8;508:4405:13;;;2000:15:8;-1:-1:-1;508:4405:13;-1:-1:-1;2058:5:8;508:4405:13;2058:5:8;;;;2170:10;;278:18;;1818:437;:::o;2065:3::-;2105:11;;2113:3;2105:11;;2096:21;;;;;;508:4405:13;2096:21:8;;2084:33;;;;:::i;:::-;;2141:1;278:18;2065:3;508:4405:13;;;;;;2030:26:8;;","linkReferences":{},"immutableReferences":{"1169":[{"start":3249,"length":32},{"start":4710,"length":32}]}}}}}}},"signatures":{"function":[{"signature":"addToWhitelist(address)","signatureHash4":"0xe43252d7","signatureHash32":"0xe43252d7ff45cae829515c48fdb060b106d1419705d9bbd0449216a6f2e0dc3c"},{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"cap()","signatureHash4":"0x355274ea","signatureHash32":"0x355274ea4c5084069935a4456a1ac3001e99e7cb12c33ca22e251b993bb2c183"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"DEFAULT_ADMIN_ROLE()","signatureHash4":"0xa217fddf","signatureHash32":"0xa217fddfde7807bb766525e432eeeecaaf4de889a05e8df9fb827257fb978cf4"},{"signature":"getRoleAdmin(bytes32)","signatureHash4":"0x248a9ca3","signatureHash32":"0x248a9ca39e7e298ea3bbd193e7d36b87492efea84ff513fd03940aaa5bc0d98f"},{"signature":"grantRole(bytes32,address)","signatureHash4":"0x2f2ff15d","signatureHash32":"0x2f2ff15deca029b64bbc0874ae59c8f39be024a95aa718b4c13ca407db350be8"},{"signature":"hasRole(bytes32,address)","signatureHash4":"0x91d14854","signatureHash32":"0x91d1485424b278bc736d5d34907ed48280c7188845bc82b33370da2b4dc1194e"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"isWhitelisted(address)","signatureHash4":"0x3af32abf","signatureHash32":"0x3af32abf6dd58f324dd88f0cedc69529dd503406094dc24662635caa70d9a021"},{"signature":"mint(address,uint256)","signatureHash4":"0x40c10f19","signatureHash32":"0x40c10f19c047ae7dfa66d6312b683d2ea3dfbcb4159e96b967c5f4b0a86f2842"},{"signature":"MINTER_ROLE()","signatureHash4":"0xd5391393","signatureHash32":"0xd5391393148b83454a7ce0feba5669f1be31824be5022ab68df7b94c6f764c96"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"pause()","signatureHash4":"0x8456cb59","signatureHash32":"0x8456cb591a934d53f6ccc6332123a165a1f3562907bf11330d847a29ca49eb89"},{"signature":"paused()","signatureHash4":"0x5c975abb","signatureHash32":"0x5c975abbf8c4d6efa68fc896e233763eb503f2318260b7bf59b19412913788b2"},{"signature":"PAUSER_ROLE()","signatureHash4":"0xe63ab1e9","signatureHash32":"0xe63ab1e9105047561658ac3165e1299fe26595759c1b0c4013fb9a4343523ad1"},{"signature":"recoverERC20(address,address,uint256)","signatureHash4":"0x1171bda9","signatureHash32":"0x1171bda97004da95beb81475259efd022a3c87c480289c19e5d530b0eaee0c83"},{"signature":"removeFromWhitelist(address)","signatureHash4":"0x8ab1d681","signatureHash32":"0x8ab1d6813892afe635553b1cefe2d6cb2839d733d9429628bd8610bb62f6ffe7"},{"signature":"renounceRole(bytes32,address)","signatureHash4":"0x36568abe","signatureHash32":"0x36568abe2c7e6c1d662bad0fe1760ac72cf2f9478a86be824d68ec83895c49e9"},{"signature":"revokeRole(bytes32,address)","signatureHash4":"0xd547741f","signatureHash32":"0xd547741fd8d55981251e167708119763c372f2b41e85a1468b0a759b055a009f"},{"signature":"setMinter(address)","signatureHash4":"0xfca3b5aa","signatureHash32":"0xfca3b5aab8d7ebda5386764271d074f4735ef11613e0aebd07331a5cfff35d05"},{"signature":"supportsInterface(bytes4)","signatureHash4":"0x01ffc9a7","signatureHash32":"0x01ffc9a7a5cef8baa21ed3c5c0d7e23accb804b619e9333b597f47a0d84076e2"},{"signature":"symbol()","signatureHash4":"0x95d89b41","signatureHash32":"0x95d89b41e2f5f391a79ec54e9d87c79d6e777c63e32c28da95b4e9e4a79250ec"},{"signature":"totalSupply()","signatureHash4":"0x18160ddd","signatureHash32":"0x18160ddd7f15c72528c2f94fd8dfe3c8d5aa26e2c50c7d81f4bc7bee8d4b7932"},{"signature":"transfer(address,uint256)","signatureHash4":"0xa9059cbb","signatureHash32":"0xa9059cbb2ab09eb219583f4a59a5d0623ade346d962bcd4e46b11da047c9049b"},{"signature":"transferFrom(address,address,uint256)","signatureHash4":"0x23b872dd","signatureHash32":"0x23b872dd7302113369cda2901243429419bec145408fa8b352b3dd92b66c680b"},{"signature":"unpause()","signatureHash4":"0x3f4ba83a","signatureHash32":"0x3f4ba83af89dc9793996d9e56b8abe6dc88cd97c9c2bb23027806e9c1ffd54dc"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"ERC20Recovered(address,address,uint256)","signatureHash4":"0xaca8fb25","signatureHash32":"0xaca8fb252cde442184e5f10e0f2e6e4029e8cd7717cae63559079610702436aa"},{"signature":"Paused(address)","signatureHash4":"0x62e78cea","signatureHash32":"0x62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a258"},{"signature":"RoleAdminChanged(bytes32,bytes32,bytes32)","signatureHash4":"0xbd79b86f","signatureHash32":"0xbd79b86ffe0ab8e8776151514217cd7cacd52c909f66475c3af44e129f0b00ff"},{"signature":"RoleGranted(bytes32,address,address)","signatureHash4":"0x2f878811","signatureHash32":"0x2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d"},{"signature":"RoleRevoked(bytes32,address,address)","signatureHash4":"0xf6391f5c","signatureHash32":"0xf6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"},{"signature":"Unpaused(address)","signatureHash4":"0x5db9ee0a","signatureHash32":"0x5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa"},{"signature":"WhitelistUpdated(address,bool)","signatureHash4":"0xf93f9a76","signatureHash32":"0xf93f9a76c1bf3444d22400a00cb9fe990e6abe9dbb333fda48859cfee864543d"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"56","address":"0x0F0df6cB17ee5E883eddFEf9153fC6036BDB4e37"}