{"matchId":"10269300","creationMatch":"exact_match","runtimeMatch":"exact_match","verifiedAt":"2025-11-20T06:04:27Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"135:226:5:-:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;135:226:5;;;;;;;:::i;:::-;;;;-1:-1:-1;;;135:226:5;;;;-1:-1:-1;135:226:5;;734:10:4;-1:-1:-1;;;;;;135:226:5;;;;;;;;;734:10:4;-1:-1:-1;;;;;135:226:5;;;;2566:40:0;;-1:-1:-1;2566:40:0;135:226:5;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;2069:17:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;2069:17:1;135:226:5;;734:10:4;8603:21:1;135:226:5;;8731:22:1;135:226:5;;;;;;;;;8731:22:1;135:226:5;734:10:4;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;8952:37:1;135:226:5;734:10:4;8952:37:1;;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;2069:17:1;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;2069:17:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:17:1;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;2069:17:1;135:226:5;;;;;;;;;;;;2069:17:1;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;;135:226:5;;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;:::o","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e292eb402db16e1b79c88897c69843108e5698f5d485301c9b5d7a07a927fd2464736f6c634300081c0033","offset":3905}},"transformations":[{"type":"insert","offset":3958,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x000000000000000000000000000000000000000000a56fa5b99019a5c8000000"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"135:226:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;1063:62:0;;:::i;:::-;-1:-1:-1;;;;;135:226:5;2162:22:0;;135:226:5;;;;;-1:-1:-1;;;;;;135:226:5;;;;;;-1:-1:-1;;;;;135:226:5;;2566:40:0;;135:226:5;2566:40:0;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;135:226:5;;;;;;;4102:11:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;3894:6:1;135:226:5;;:::i;:::-;;;734:10:4;;3894:6:1;:::i;:::-;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;734:10:4;;135:226:5;;4102:11:1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;-1:-1:-1;135:226:5;;6792:35:1;;;;135:226:5;;6928:34:1;135:226:5;;734:10:4;;6928:34:1;:::i;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;1063:62:0;;:::i;:::-;734:10:4;8603:21:1;135:226:5;;8731:22:1;135:226:5;8731:22:1;135:226:5;8731:22:1;:::i;:::-;;135:226:5;734:10:4;135:226:5;;;;;;;;;;;;;;;;;;;;8952:37:1;135:226:5;734:10:4;8952:37:1;;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;;2457:7:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;2457:7:1;135:226:5;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:1;135:226:5;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;1063:62:0;;:::i;:::-;135:226:5;;;-1:-1:-1;;;;;;135:226:5;;;;-1:-1:-1;;;;;135:226:5;2566:40:0;135:226:5;;2566:40:0;135:226:5;;;;;;;-1:-1:-1;;135:226:5;;;;-1:-1:-1;;;;;135:226:5;;:::i;:::-;;;;3519:9:1;135:226:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;6021:38:1;135:226:5;;:::i;:::-;734:10:4;135:226:5;;4102:11:1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;6021:38:1;135:226:5;-1:-1:-1;135:226:5;;;;;6021:38:1;:::i;:::-;734:10:4;;6021:38:1;:::i;135:226:5:-;;;;;;-1:-1:-1;;135:226:5;;;;;;;3186:2:1;135:226:5;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;135:226:5;;;;;;4102:11:1;135:226:5;;;;;;;;734:10:4;135:226:5;;;;;;;;;;;;;;11244:37:1;;11240:243;;135:226:5;5424:6:1;;;;:::i;11240:243::-;11305:26;;;135:226:5;;11432:25:1;135:226:5;5424:6:1;135:226:5;;734:10:4;11432:25:1;;:::i;:::-;11240:243;;135:226:5;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;3342:12:1;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;4606:6:1;135:226:5;;:::i;:::-;;;734:10:4;;4606:6:1;:::i;135:226:5:-;;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;135:226:5;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;10457:340:1;-1:-1:-1;;;;;135:226:5;;10558:19:1;;135:226:5;;-1:-1:-1;;;;;135:226:5;;10636:21:1;;135:226:5;;;10758:32:1;135:226:5;;10575:1:1;135:226:5;10707:11:1;135:226:5;;;10575:1:1;135:226:5;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;10758:32:1;10457:340::o;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;7456:788:1;-1:-1:-1;;;;;135:226:5;;7552:18:1;;135:226:5;;-1:-1:-1;;;;;135:226:5;;7630:16:1;;135:226:5;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;7568:1:1;135:226:5;;7801:21:1;;;135:226:5;;;8163:26:1;135:226:5;;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;;7568:1:1;135:226:5;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;7568:1:1;135:226:5;;;;;;;;;;;;8163:26:1;7456:788::o;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;1359:130:0;1273:6;135:226:5;-1:-1:-1;;;;;135:226:5;734:10:4;1422:23:0;135:226:5;;1359:130:0:o;135:226:5:-;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"cborAuxdata":{"1":{"value":"0xa2646970667358221220e292eb402db16e1b79c88897c69843108e5698f5d485301c9b5d7a07a927fd2464736f6c634300081c0033","offset":2828}},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x85f94c95bad810f8412303c0f8091bb44b1d5c6772f8051eddf60784d8243d8e","blockNumber":"314877056","transactionIndex":"26","deployer":"0xa82a1b38C09CC6856a3F0F4955D99E99e3Cf5000"},"sources":{"@openzeppelin/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@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/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/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/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"},"contracts/LionToken.sol":{"content":"pragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\ncontract LionToken is Ownable, ERC20 {\n  constructor(uint256 value) ERC20('Loaded Lions', 'LION') {\n    _mint(_msgSender(), value);\n  }\n\n  function mint(uint256 value) onlyOwner external {\n    _mint(_msgSender(), value);\n  }\n}"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"libraries":{},"optimizer":{"runs":100,"enabled":true},"evmVersion":"paris"},"name":"LionToken","fullyQualifiedName":"contracts/LionToken.sol:LionToken"},"abi":[{"type":"constructor","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"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":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","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":"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":"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":"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":"mint","type":"function","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"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":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"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":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","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"},{"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":"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":"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":"uint256","name":"value","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","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":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","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."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"kind":"dev","methods":{"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}."},"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`."},"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."},"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"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`."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"userdoc":{"kind":"user","methods":{},"version":1}},"settings":{"compilationTarget":{"contracts/LionToken.sol":"LionToken"},"evmVersion":"paris","libraries":{},"metadata":{"bytecodeHash":"ipfs"},"optimizer":{"enabled":true,"runs":100},"remappings":[],"viaIR":true},"sources":{"@openzeppelin/contracts/access/Ownable.sol":{"keccak256":"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218","license":"MIT","urls":["bzz-raw://fc980984badf3984b6303b377711220e067722bbd6a135b24669ff5069ef9f32","dweb:/ipfs/QmPHXMSXj99XjSVM21YsY6aNtLLjLVXDbyN76J5HQYvvrz"]},"@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/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"]},"contracts/LionToken.sol":{"keccak256":"0x55dee6509254d0142f3ee0e6e100a4c28b98b91766da653518d5ae9ca331e506","urls":["bzz-raw://4d573342de52b3d484ff9c05f3365da97468f65a25f31dc86f1c3b09a7ed996c","dweb:/ipfs/QmP5DPTmoWCAaqBKdiBU83Kkwuog3XWFrtTmN5HQX6Ckna"]}},"version":1},"storageLayout":{"types":{"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","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_address","astId":7,"label":"_owner","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"1","type":"t_mapping(t_address,t_uint256)","astId":128,"label":"_balances","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":134,"label":"_allowances","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"3","type":"t_uint256","astId":136,"label":"_totalSupply","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"4","type":"t_string_storage","astId":138,"label":"_name","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"5","type":"t_string_storage","astId":140,"label":"_symbol","offset":0,"contract":"contracts/LionToken.sol:LionToken"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","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."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"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}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"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."},"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}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"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/LionToken.sol":{"id":5},"@openzeppelin/contracts/utils/Context.sol":{"id":4},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"additionalInput":null,"stdJsonInput":{"sources":{"contracts/LionToken.sol":{"content":"pragma solidity ^0.8.0;\n\nimport \"@openzeppelin/contracts/token/ERC20/ERC20.sol\";\nimport \"@openzeppelin/contracts/access/Ownable.sol\";\n\ncontract LionToken is Ownable, ERC20 {\n  constructor(uint256 value) ERC20('Loaded Lions', 'LION') {\n    _mint(_msgSender(), value);\n  }\n\n  function mint(uint256 value) onlyOwner external {\n    _mint(_msgSender(), value);\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/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)\n\npragma solidity ^0.8.0;\n\nimport \"../utils/Context.sol\";\n\n/**\n * @dev Contract module which provides a basic access control mechanism, where\n * there is an account (an owner) that can be granted exclusive access to\n * specific functions.\n *\n * By default, the owner account will be the one that deploys the contract. This\n * can later be changed with {transferOwnership}.\n *\n * This module is used through inheritance. It will make available the modifier\n * `onlyOwner`, which can be applied to your functions to restrict their use to\n * the owner.\n */\nabstract contract Ownable is Context {\n    address private _owner;\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the deployer as the initial owner.\n     */\n    constructor() {\n        _transferOwnership(_msgSender());\n    }\n\n    /**\n     * @dev Throws if called by any account other than the owner.\n     */\n    modifier onlyOwner() {\n        _checkOwner();\n        _;\n    }\n\n    /**\n     * @dev Returns the address of the current owner.\n     */\n    function owner() public view virtual returns (address) {\n        return _owner;\n    }\n\n    /**\n     * @dev Throws if the sender is not the owner.\n     */\n    function _checkOwner() internal view virtual {\n        require(owner() == _msgSender(), \"Ownable: caller is not the owner\");\n    }\n\n    /**\n     * @dev Leaves the contract without owner. It will not be possible to call\n     * `onlyOwner` functions. Can only be called by the current owner.\n     *\n     * NOTE: Renouncing ownership will leave the contract without an owner,\n     * thereby disabling any functionality that is only available to the owner.\n     */\n    function renounceOwnership() public virtual onlyOwner {\n        _transferOwnership(address(0));\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Can only be called by the current owner.\n     */\n    function transferOwnership(address newOwner) public virtual onlyOwner {\n        require(newOwner != address(0), \"Ownable: new owner is the zero address\");\n        _transferOwnership(newOwner);\n    }\n\n    /**\n     * @dev Transfers ownership of the contract to a new account (`newOwner`).\n     * Internal function without access restriction.\n     */\n    function _transferOwnership(address newOwner) internal virtual {\n        address oldOwner = _owner;\n        _owner = newOwner;\n        emit OwnershipTransferred(oldOwner, newOwner);\n    }\n}\n"},"@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/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,"libraries":{},"optimizer":{"runs":100,"enabled":true},"evmVersion":"paris"}},"stdJsonOutput":{"sources":{"contracts/LionToken.sol":{"id":5},"@openzeppelin/contracts/utils/Context.sol":{"id":4},"@openzeppelin/contracts/access/Ownable.sol":{"id":0},"@openzeppelin/contracts/token/ERC20/ERC20.sol":{"id":1},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"id":2},"@openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol":{"id":3}},"contracts":{"contracts/LionToken.sol":{"LionToken":{"abi":[{"type":"constructor","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"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":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","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":"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":"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":"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":"mint","type":"function","inputs":[{"name":"value","type":"uint256","internalType":"uint256"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"name","type":"function","inputs":[],"outputs":[{"name":"","type":"string","internalType":"string"}],"stateMutability":"view"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"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":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"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\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"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\"},{\"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\":\"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\":\"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\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"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\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"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.\"},\"Transfer(address,address,uint256)\":{\"details\":\"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero.\"}},\"kind\":\"dev\",\"methods\":{\"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}.\"},\"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`.\"},\"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.\"},\"name()\":{\"details\":\"Returns the name of the token.\"},\"owner()\":{\"details\":\"Returns the address of the current owner.\"},\"renounceOwnership()\":{\"details\":\"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner.\"},\"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`.\"},\"transferOwnership(address)\":{\"details\":\"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner.\"}},\"version\":1},\"userdoc\":{\"kind\":\"user\",\"methods\":{},\"version\":1}},\"settings\":{\"compilationTarget\":{\"contracts/LionToken.sol\":\"LionToken\"},\"evmVersion\":\"paris\",\"libraries\":{},\"metadata\":{\"bytecodeHash\":\"ipfs\"},\"optimizer\":{\"enabled\":true,\"runs\":100},\"remappings\":[],\"viaIR\":true},\"sources\":{\"@openzeppelin/contracts/access/Ownable.sol\":{\"keccak256\":\"0xba43b97fba0d32eb4254f6a5a297b39a19a247082a02d6e69349e071e2946218\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://fc980984badf3984b6303b377711220e067722bbd6a135b24669ff5069ef9f32\",\"dweb:/ipfs/QmPHXMSXj99XjSVM21YsY6aNtLLjLVXDbyN76J5HQYvvrz\"]},\"@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/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\"]},\"contracts/LionToken.sol\":{\"keccak256\":\"0x55dee6509254d0142f3ee0e6e100a4c28b98b91766da653518d5ae9ca331e506\",\"urls\":[\"bzz-raw://4d573342de52b3d484ff9c05f3365da97468f65a25f31dc86f1c3b09a7ed996c\",\"dweb:/ipfs/QmP5DPTmoWCAaqBKdiBU83Kkwuog3XWFrtTmN5HQX6Ckna\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","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."},"Transfer(address,address,uint256)":{"details":"Emitted when `value` tokens are moved from one account (`from`) to another (`to`). Note that `value` may be zero."}},"methods":{"name()":{"details":"Returns the name of the token."},"owner()":{"details":"Returns the address of the current owner."},"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}."},"totalSupply()":{"details":"See {IERC20-totalSupply}."},"balanceOf(address)":{"details":"See {IERC20-balanceOf}."},"renounceOwnership()":{"details":"Leaves the contract without owner. It will not be possible to call `onlyOwner` functions. Can only be called by the current owner. NOTE: Renouncing ownership will leave the contract without an owner, thereby disabling any functionality that is only available to the owner."},"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."},"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}."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."},"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_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_string_storage":{"label":"string","encoding":"bytes","numberOfBytes":"32"},"t_mapping(t_address,t_uint256)":{"key":"t_address","label":"mapping(address => uint256)","value":"t_uint256","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_address","astId":7,"label":"_owner","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"1","type":"t_mapping(t_address,t_uint256)","astId":128,"label":"_balances","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"2","type":"t_mapping(t_address,t_mapping(t_address,t_uint256))","astId":134,"label":"_allowances","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"3","type":"t_uint256","astId":136,"label":"_totalSupply","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"4","type":"t_string_storage","astId":138,"label":"_name","offset":0,"contract":"contracts/LionToken.sol:LionToken"},{"slot":"5","type":"t_string_storage","astId":140,"label":"_symbol","offset":0,"contract":"contracts/LionToken.sol:LionToken"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"135:226:5:-:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;135:226:5;;;;;;;:::i;:::-;;;;-1:-1:-1;;;135:226:5;;;;-1:-1:-1;135:226:5;;734:10:4;-1:-1:-1;;;;;;135:226:5;;;;;;;;;734:10:4;-1:-1:-1;;;;;135:226:5;;;;2566:40:0;;-1:-1:-1;2566:40:0;135:226:5;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;2069:17:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;2069:17:1;135:226:5;;734:10:4;8603:21:1;135:226:5;;8731:22:1;135:226:5;;;;;;;;;8731:22:1;135:226:5;734:10:4;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;8952:37:1;135:226:5;734:10:4;8952:37:1;;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;2069:17:1;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;2069:17:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2069:17:1;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;2069:17:1;135:226:5;;;;;;;;;;;;2069:17:1;135:226:5;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;-1:-1:-1;;135:226:5;;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;:::o","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"135:226:5:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;1063:62:0;;:::i;:::-;-1:-1:-1;;;;;135:226:5;2162:22:0;;135:226:5;;;;;-1:-1:-1;;;;;;135:226:5;;;;;;-1:-1:-1;;;;;135:226:5;;2566:40:0;;135:226:5;2566:40:0;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;135:226:5;;;;;;;4102:11:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;3894:6:1;135:226:5;;:::i;:::-;;;734:10:4;;3894:6:1;:::i;:::-;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;734:10:4;;135:226:5;;4102:11:1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;-1:-1:-1;135:226:5;;6792:35:1;;;;135:226:5;;6928:34:1;135:226:5;;734:10:4;;6928:34:1;:::i;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;1063:62:0;;:::i;:::-;734:10:4;8603:21:1;135:226:5;;8731:22:1;135:226:5;8731:22:1;135:226:5;8731:22:1;:::i;:::-;;135:226:5;734:10:4;135:226:5;;;;;;;;;;;;;;;;;;;;8952:37:1;135:226:5;734:10:4;8952:37:1;;135:226:5;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;;2457:7:1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;2457:7:1;135:226:5;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2457:7:1;135:226:5;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;1063:62:0;;:::i;:::-;135:226:5;;;-1:-1:-1;;;;;;135:226:5;;;;-1:-1:-1;;;;;135:226:5;2566:40:0;135:226:5;;2566:40:0;135:226:5;;;;;;;-1:-1:-1;;135:226:5;;;;-1:-1:-1;;;;;135:226:5;;:::i;:::-;;;;3519:9:1;135:226:5;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;6021:38:1;135:226:5;;:::i;:::-;734:10:4;135:226:5;;4102:11:1;135:226:5;;;;;;;;;;;;-1:-1:-1;135:226:5;;;6021:38:1;135:226:5;-1:-1:-1;135:226:5;;;;;6021:38:1;:::i;:::-;734:10:4;;6021:38:1;:::i;135:226:5:-;;;;;;-1:-1:-1;;135:226:5;;;;;;;3186:2:1;135:226:5;;;;;;;;;-1:-1:-1;;135:226:5;;;;;;:::i;:::-;;;:::i;:::-;-1:-1:-1;;;;;135:226:5;;;;;;4102:11:1;135:226:5;;;;;;;;734:10:4;135:226:5;;;;;;;;;;;;;;11244:37:1;;11240:243;;135:226:5;5424:6:1;;;;:::i;11240:243::-;11305:26;;;135:226:5;;11432:25:1;135:226:5;5424:6:1;135:226:5;;734:10:4;11432:25:1;;:::i;:::-;11240:243;;135:226:5;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;;3342:12:1;135:226:5;;;;;;;;;;;;;-1:-1:-1;;135:226:5;;;;4606:6:1;135:226:5;;:::i;:::-;;;734:10:4;;4606:6:1;:::i;135:226:5:-;;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;;135:226:5;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1;135:226:5;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;135:226:5;;;;;;:::o;:::-;;;;-1:-1:-1;;;;;135:226:5;;;;;;:::o;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;10457:340:1;-1:-1:-1;;;;;135:226:5;;10558:19:1;;135:226:5;;-1:-1:-1;;;;;135:226:5;;10636:21:1;;135:226:5;;;10758:32:1;135:226:5;;10575:1:1;135:226:5;10707:11:1;135:226:5;;;10575:1:1;135:226:5;;-1:-1:-1;135:226:5;;;;;-1:-1:-1;135:226:5;;;;;;;10758:32:1;10457:340::o;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;7456:788:1;-1:-1:-1;;;;;135:226:5;;7552:18:1;;135:226:5;;-1:-1:-1;;;;;135:226:5;;7630:16:1;;135:226:5;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;7568:1:1;135:226:5;;7801:21:1;;;135:226:5;;;8163:26:1;135:226:5;;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;;7568:1:1;135:226:5;;;7568:1:1;135:226:5;7768:9:1;135:226:5;;;7568:1:1;135:226:5;;;;;;;;;;;;8163:26:1;7456:788::o;135:226:5:-;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;;;;;;;;;;;-1:-1:-1;;;135:226:5;;;;;;;1359:130:0;1273:6;135:226:5;-1:-1:-1;;;;;135:226:5;734:10:4;1422:23:0;135:226:5;;1359:130:0:o;135:226:5:-;;;;;;;;;;;;;;;;;;;;;;;;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"allowance(address,address)","signatureHash4":"0xdd62ed3e","signatureHash32":"0xdd62ed3e90e97b3d417db9c0c7522647811bafca5afc6694f143588d255fdfb4"},{"signature":"approve(address,uint256)","signatureHash4":"0x095ea7b3","signatureHash32":"0x095ea7b334ae44009aa867bfb386f5c3b4b443ac6f0ee573fa91c4608fbadfba"},{"signature":"balanceOf(address)","signatureHash4":"0x70a08231","signatureHash32":"0x70a08231b98ef4ca268c9cc3f6b4590e4bfec28280db06bb5d45e689f2a360be"},{"signature":"decimals()","signatureHash4":"0x313ce567","signatureHash32":"0x313ce567add4d438edf58b94ff345d7d38c45b17dfc0f947988d7819dca364f9"},{"signature":"decreaseAllowance(address,uint256)","signatureHash4":"0xa457c2d7","signatureHash32":"0xa457c2d77307f80ff2f3ac810ec99eb18ae2cffee13b29c90c9324546e374be5"},{"signature":"increaseAllowance(address,uint256)","signatureHash4":"0x39509351","signatureHash32":"0x39509351d3325647dde3fdd3c8b249adfe89ef4f16d76d83768e6df7a5cd81d6"},{"signature":"mint(uint256)","signatureHash4":"0xa0712d68","signatureHash32":"0xa0712d680358d64f694230b7cc0b277c73686bdf768385d55cd7c547d0ffd30e"},{"signature":"name()","signatureHash4":"0x06fdde03","signatureHash32":"0x06fdde0383f15d582d1a74511486c9ddf862a882fb7904b3d9fe9b8b8e58a796"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"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":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"Approval(address,address,uint256)","signatureHash4":"0x8c5be1e5","signatureHash32":"0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925"},{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"},{"signature":"Transfer(address,address,uint256)","signatureHash4":"0xddf252ad","signatureHash32":"0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"}],"error":[]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"exact_match","chainId":"42161","address":"0x527e8D368298deA5a53be257e5300F4DBafb7a97"}