{"matchId":"42942468","creationMatch":"match","runtimeMatch":"match","verifiedAt":"2026-07-27T20:23:29Z","creationBytecode":{"onchainBytecode":"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","recompiledBytecode":"0x6080604052346103e157610ed380380380610019816103fd565b92833981016060828203126103e15761003182610422565b60208301516001600160401b0381116103e15783019282601f850112156103e15783519061006661006183610436565b6103fd565b94602086848152016020819460051b830101918683116103e157602001905b8282106103e5575050506040810151906001600160401b0382116103e157019183601f840112156103e1578251926100bf61006185610436565b9460208686815201916020839660051b8201019182116103e157602001915b8183106103c6575050506001600160a01b031680156103b3575f80546001600160a01b03198116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a360018055825193805185036103a45751906001600160401b03821161033957680100000000000000008211610339576002548260025580831061036a575b5060025f5260205f205f5b83811061034d5750508351929150506001600160401b0382116103395768010000000000000000821161033957600354826003558083106102e8575b509060035f5260205f208160041c915f5b8381106102a85750600f19811690038061025b575b505050505f6004555f5b82811061020257604051610a6f90816104648239f35b81518110156102475761ffff60208260051b84010151169060045491820180921161023357600191600455016101ec565b634e487b7160e01b5f52601160045260245ffd5b634e487b7160e01b5f52603260045260245ffd5b925f935f5b8181106102755750505001555f8080806101e2565b909194602061029e60019261ffff8951169085851b61ffff809160031b9316831b921b19161790565b9601929101610260565b5f5f5b601081106102c05750838201556001016101cd565b865190969160019160209161ffff60048b901b81811b199092169216901b17920196016102ab565b6103189060035f5260205f20600f80860160041c820192601e8760011b168061031e575b500160041c019061044d565b5f6101bc565b5f198501908154905f199060200360031b1c1690555f61030c565b634e487b7160e01b5f52604160045260245ffd5b82516001600160a01b031681830155602090920191600101610180565b60025f5261039e907f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace90810190840161044d565b5f610175565b631df89e8b60e01b5f5260045ffd5b631e4fbdf760e01b5f525f60045260245ffd5b825161ffff811681036103e1578152602092830192016100de565b5f80fd5b602080916103f284610422565b815201910190610085565b6040519190601f01601f191682016001600160401b0381118382101761033957604052565b51906001600160a01b03821682036103e157565b6001600160401b0381116103395760051b60200190565b818110610458575050565b5f815560010161044d56fe608080604052600436101561001c575b50361561001a575f80fd5b005b5f3560e01c9081633a98ef39146108d3575080634e71d92d146107ed57806357a858fc146107b1578063715018a61461075a5780638da5cb5b14610733578063bc45dad01461034b578063d1bc76a114610309578063d512143e146101185763f2fde38b1461008b575f61000f565b34610114576020366003190112610114576004356001600160a01b03811690819003610114576100b9610a12565b8015610101575f80546001600160a01b03198116831782556001600160a01b0316907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e09080a3005b631e4fbdf760e01b5f525f60045260245ffd5b5f80fd5b346101145760203660031901126101145760043567ffffffffffffffff81116101145761014990369060040161091a565b6101516109f2565b6003545f5b8281106101635760018055005b602460206001600160a01b0361018261017d85888a6109ce565b6109de565b16604051928380926370a0823160e01b82523060048301525afa9081156102fe575f916102cd575b50801561029f575f5b8381106101c4575050600101610156565b6101d761017d84878995999896986109ce565b6101e08261094b565b905460039190911b1c6001600160a01b031661021b61021261ffff610204866108ed565b90549060031b1c168a610963565b60045490610976565b6040519163a9059cbb60e01b5f5260045260245260205f60448180865af19060015f511482161561027e575b6040521561025e57506001019490949391936101b3565b635274afe760e01b5f9081526001600160a01b0391909116600452602490fd5b90600181151661029657823b15153d15161690610247565b503d5f823e3d90fd5b6102ad61017d8386886109ce565b63465c2fa960e11b5f9081526001600160a01b0391909116600452602490fd5b90506020813d82116102f6575b816102e760209383610994565b810103126101145751856101aa565b3d91506102da565b6040513d5f823e3d90fd5b34610114576020366003190112610114576004356002548110156101145761033260209161094b565b905460405160039290921b1c6001600160a01b03168152f35b346101145760403660031901126101145760043567ffffffffffffffff81116101145761037c90369060040161091a565b60243567ffffffffffffffff81116101145761039c90369060040161091a565b90916103a6610a12565b6103af816109b6565b936103bd6040519586610994565b8185526020850190819260051b81019036821161011457915b818310610713575050506103e9826109b6565b926103f76040519485610994565b8284526020840190819360051b81019036821161011457915b8183106106f857505050825193805185036106e957519067ffffffffffffffff821161064457600160401b82116106445760025482600255808310610695575b5060025f525f5b8281106106585750505081519067ffffffffffffffff821161064457600160401b821161064457600354826003558083106105c1575b509060035f528060041c905f5b8281106105745750600f19811690038061051a575b5050505f6004555f5b8281106104c157005b81518110156105065761ffff60208260051b8401015116906004549182018092116104f257600191600455016104b8565b634e487b7160e01b5f52601160045260245ffd5b634e487b7160e01b5f52603260045260245ffd5b915f925f5b818110610541575050505f516020610a4f5f395f51905f5201558280806104af565b909193602061056a60019261ffff8851169085851b61ffff809160031b9316831b921b19161790565b950192910161051f565b5f5f5b6010811061059957505f516020610a4f5f395f51905f5282015560010161049a565b855190959160019160209161ffff60048a901b81811b199092169216901b1792019501610577565b61060490600f80850160041c91601e8660011b168061060a575b500160041c5f516020610a4f5f395f51905f5201905f516020610a4f5f395f51905f5201610a38565b8461048d565b7fc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85a8401908154905f199060200360031b1c169055886105db565b634e487b7160e01b5f52604160045260245ffd5b81516001600160a01b03167f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace820155602090910190600101610457565b6106e3907f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace01837f405787fa12a823e0f2b7631cc41b3ba8828b3321ca811111fa75cd3aa3bb5ace01610a38565b85610450565b631df89e8b60e01b5f5260045ffd5b823561ffff8116810361011457815260209283019201610410565b82356001600160a01b0381168103610114578152602092830192016103d6565b34610114575f366003190112610114575f546040516001600160a01b039091168152602090f35b34610114575f36600319011261011457610772610a12565b5f80546001600160a01b0319811682556001600160a01b03167f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e08280a3005b34610114576020366003190112610114576004356003548110156101145761ffff6107dd6020926108ed565b90549060031b1c16604051908152f35b34610114575f366003190112610114576108056109f2565b600354475f5b8281106108185760018055005b5f8080806108258561094b565b905460039190911b1c6001600160a01b031661085761021261ffff610849896108ed565b90549060031b1c1689610963565b905af13d156108ce573d67ffffffffffffffff81116106445760405190610888601f8201601f191660200183610994565b81525f60203d92013e5b1561089f5760010161080b565b6108a89061094b565b905463201be19160e01b5f90815260039290921b1c6001600160a01b0316600452602490fd5b610892565b34610114575f366003190112610114576020906004548152f35b906003548210156105065760035f52600482901c5f516020610a4f5f395f51905f52019160011b601e1690565b9181601f840112156101145782359167ffffffffffffffff8311610114576020808501948460051b01011161011457565b6002548110156105065760025f5260205f2001905f90565b818102929181159184041417156104f257565b8115610980570490565b634e487b7160e01b5f52601260045260245ffd5b90601f8019910116810190811067ffffffffffffffff82111761064457604052565b67ffffffffffffffff81116106445760051b60200190565b91908110156105065760051b0190565b356001600160a01b03811681036101145790565b600260015414610a03576002600155565b633ee5aeb560e01b5f5260045ffd5b5f546001600160a01b03163303610a2557565b63118cdaa760e01b5f523360045260245ffd5b818110610a43575050565b5f8155600101610a3856fec2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b","sourceMap":"368:2289:9:-:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;368:2289:9;1273:26:0;;1269:95;;-1:-1:-1;368:2289:9;;-1:-1:-1;;;;;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;3052:40:0;;-1:-1:-1;3052:40:0;1857:1:7;;;368:2289:9;;;;;2297:28;;2293:82;;368:2289;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;2385:24;368:2289;;2385:24;368:2289;;;;;;;;2385:24;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;-1:-1:-1;368:2289:9;;;;;;-1:-1:-1;;368:2289:9;;;;-1:-1:-1;;;;;;;368:2289:9;;;;;;;;;2419:16;368:2289;;2419:16;368:2289;;;;;;;;;2419:16;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;;-1:-1:-1;;;368:2289:9;;;;;;;;1857:1:7;;;;-1:-1:-1;368:2289:9;1857:1:7;-1:-1:-1;2491:10:9;;;;;;368:2289;;;;;;;;;2476:13;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;1857:1:7;;368:2289:9;1857:1:7;368:2289:9;2476:13;;368:2289;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;-1:-1:-1;368:2289:9;-1:-1:-1;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;1857:1:7;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;-1:-1:-1;368:2289:9;;;;1857:1:7;368:2289:9;;;;;;;;;1857:1:7;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;2419:16;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;;;;;;;;;;1857:1:7;368:2289:9;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;1857:1:7;368:2289:9;;;;2385:24;-1:-1:-1;368:2289:9;;;;;;;;;;;:::i;:::-;;;;2293:82;2348:16;;;-1:-1:-1;2348:16:9;;-1:-1:-1;2348:16:9;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;368:2289:9;;-1:-1:-1;1322:31:0;368:2289:9;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;368:2289:9;;;;;;:::o;:::-;-1:-1:-1;;;;;368:2289:9;;;;;;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;","linkReferences":{},"cborAuxdata":{},"transformations":[{"type":"insert","offset":3795,"reason":"constructorArguments"}],"transformationValues":{"constructorArguments":"0x0000000000000000000000006aa68c46ed86161eb318b1396f7b79e386e88676000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c0000000000000000000000000000000000000000000000000000000000000000200000000000000000000000086fbaeb3d6b5247f420590d303a6ffc9cd5237900000000000000000000000006aa68c46ed86161eb318b1396f7b79e386e88676000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000040000000000000000000000000000000000000000000000000000000000000001"}},"runtimeBytecode":{"onchainBytecode":"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","recompiledBytecode":"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","sourceMap":"368:2289:9:-:0;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;1500:62:0;;:::i;:::-;2627:22;;2623:91;;368:2289:9;;;-1:-1:-1;;;;;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;3052:40:0;;368:2289:9;3052:40:0;368:2289:9;2623:91:0;2672:31;;;368:2289:9;2672:31:0;368:2289:9;;;;;2672:31:0;368:2289:9;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;;;;;;:::i;:::-;2466:103:7;;:::i;:::-;1440:6:9;368:2289;;1484:16;;;;;;1338:4:5;1899:1:7;;368:2289:9;1469:13;8539:1058:5;368:2289:9;-1:-1:-1;;;;;1540:10:9;;;;;;:::i;:::-;;:::i;:::-;368:2289;;;;;;;;;;1540:35;;1569:4;368:2289;1540:35;;368:2289;1540:35;;;;;;;368:2289;1540:35;;;1469:13;1594:17;;;1590:84;;368:2289;1708:16;;;;;;368:2289;;1338:4:5;368:2289:9;1469:13;;1693;1745:10;;;;;;;;;;;:::i;:::-;1769:13;;;:::i;:::-;368:2289;;1440:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;1784:40;1785:24;368:2289;1800:9;;;:::i;:::-;368:2289;;;1440:6;368:2289;;;1785:24;;:::i;:::-;368:2289;;1784:40;;:::i;:::-;368:2289;8539:1058:5;8504:24;;;;368:2289:9;8539:1058:5;368:2289:9;8539:1058:5;;;368:2289:9;;8539:1058:5;;;;;;;1338:4;368:2289:9;8539:1058:5;;;;;;;1693:13:9;368:2289;8539:1058:5;1305:38;1301:116;;368:2289:9;1338:4:5;368:2289:9;1693:13;;;;;;;;1301:116:5;-1:-1:-1;;;368:2289:9;1366:40:5;;;-1:-1:-1;;;;;368:2289:9;;;;;;8539:1058:5;;1366:40;8539:1058;;1338:4;8539:1058;;;;;;;;;;;;;;;;;;;368:2289:9;8539:1058:5;;;;;1590:84:9;1648:10;;;;;;:::i;:::-;-1:-1:-1;;;368:2289:9;1638:21;;;-1:-1:-1;;;;;368:2289:9;;;;;;8539:1058:5;;1638:21:9;1540:35;;;368:2289;1540:35;;;;;;;;;368:2289;1540:35;;;:::i;:::-;;;368:2289;;;;;1540:35;;;;;;-1:-1:-1;1540:35:9;;;368:2289;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;561:27;368:2289;561:27;;;;;;368:2289;561:27;;:::i;:::-;368:2289;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;1500:62:0;;;;:::i;:::-;368:2289:9;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2297:28;;2293:82;;368:2289;;;;;;;-1:-1:-1;;;368:2289:9;;;;2385:24;368:2289;;2385:24;368:2289;;;;;;;;2385:24;368:2289;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;2419:16;368:2289;;2419:16;368:2289;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;;;;;1899:1:7;;;368:2289:9;;1899:1:7;368:2289:9;2491:10;;;;;;368:2289;2476:13;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1899:1:7;368:2289:9;1899:1:7;368:2289:9;2476:13;;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;-1:-1:-1;;;;;;;;;;;368:2289:9;;:::i;:::-;;;;;;;;;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2293:82;2348:16;;;368:2289;2348:16;368:2289;;2348:16;368:2289;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;1500:62:0;;:::i;:::-;368:2289:9;;;-1:-1:-1;;;;;;368:2289:9;;;;-1:-1:-1;;;;;368:2289:9;3052:40:0;368:2289:9;;3052:40:0;368:2289:9;;;;;;;-1:-1:-1;;368:2289:9;;;;;;594:22;368:2289;594:22;;;;;368:2289;594:22;368:2289;594:22;;:::i;:::-;368:2289;;;594:22;368:2289;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;2466:103:7;;:::i;:::-;877:6:9;368:2289;923:21;368:2289;1006:10;;;;;;368:2289;1899:1:7;;368:2289:9;991:13;368:2289;1046:13;;;;;;:::i;:::-;368:2289;;877:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;1073:40;1074:24;368:2289;1089:9;;;:::i;:::-;368:2289;;;877:6;368:2289;;;1074:24;;:::i;1073:40::-;1046:73;;;368:2289;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;:::i;:::-;;;;;;;;;;1137:8;1133:79;;368:2289;;991:13;;1133:79;1183:13;;;:::i;:::-;368:2289;;-1:-1:-1;;;368:2289:9;1172:25;;;877:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;;;;;1172:25;368:2289;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;877:6;368:2289;;;;;;877:6;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;1046:10;368:2289;;;;;;1046:10;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;-1:-1:-1;368:2289:9;:::o;:::-;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;;;;368:2289:9;;;;;;;:::o;2575:307:7:-;1899:1;2702:7;368:2289:9;2702:18:7;2698:86;;1899:1;2702:7;1899:1;2575:307::o;2698:86::-;2743:30;;;-1:-1:-1;2743:30:7;;-1:-1:-1;2743:30:7;1796:162:0;1710:6;368:2289:9;-1:-1:-1;;;;;368:2289:9;735:10:6;1855:23:0;1851:101;;1796:162::o;1851:101::-;1901:40;;;1710:6;1901:40;735:10:6;1901:40:0;368:2289:9;;1710:6:0;1901:40;368:2289:9;;;;;;;;:::o;:::-;;;;;;;","linkReferences":{},"cborAuxdata":{},"immutableReferences":{},"transformations":[],"transformationValues":{}},"deployment":{"transactionHash":"0x128d97374e0f1d3842a802c3d9d2755c03473d2271ac58d1c99b99aba84b3319","blockNumber":"25626511","transactionIndex":"318","deployer":"0xDe123e2A7dDcf4088986CC10F4099070466C31E0"},"sources":{"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0, 0x64, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\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"},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"src/FeeSplitter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport { Ownable } from \"openzeppelin-contracts/access/Ownable.sol\";\nimport { IERC20 } from \"openzeppelin-contracts/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { ReentrancyGuard } from \"openzeppelin-contracts/utils/ReentrancyGuard.sol\";\n\ncontract FeeSplitter is Ownable, ReentrancyGuard {\n    using SafeERC20 for IERC20;\n\n    error CallFailed(address recipient);\n    error NoBalance(IERC20 token);\n    error InvalidLengths();\n\n    address[] public recipients;\n    uint16[] public shares;\n    uint256 public totalShares;\n\n    constructor(address _owner, address[] memory _recipients, uint16[] memory _shares) Ownable(_owner) {\n        _setRecipients(_recipients, _shares);\n    }\n\n    function claim() public nonReentrant {\n        uint256 length = shares.length;\n        uint256 totalBalance = address(this).balance;\n\n        bool success = false;\n\n        for (uint256 i = 0; i < length;) {\n            (success,) = recipients[i].call{ value: (totalBalance * shares[i]) / totalShares }(\"\");\n            if (!success) {\n                revert CallFailed(recipients[i]);\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function claimERC20(IERC20[] calldata _tokens) public nonReentrant {\n        uint256 tokensLength = _tokens.length;\n        uint256 sharesLength = shares.length;\n\n        for (uint256 i = 0; i < tokensLength;) {\n            uint256 totalBalance = _tokens[i].balanceOf(address(this));\n\n            if (totalBalance == 0) {\n                revert NoBalance(_tokens[i]);\n            }\n\n            for (uint256 j = 0; j < sharesLength;) {\n                _tokens[i].safeTransfer(recipients[j], (totalBalance * shares[j]) / totalShares);\n\n                unchecked {\n                    ++j;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function setRecipients(address[] calldata _recipients, uint16[] calldata _shares) external onlyOwner {\n        _setRecipients(_recipients, _shares);\n    }\n\n    function _setRecipients(address[] memory _recipients, uint16[] memory _shares) internal {\n        uint256 length = _shares.length;\n        if (length != _recipients.length) {\n            revert InvalidLengths();\n        }\n\n        recipients = _recipients;\n        shares = _shares;\n\n        totalShares = 0;\n        for (uint256 i = 0; i < length;) {\n            totalShares += _shares[i];\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    receive() external payable { }\n}\n"},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Provides information about the current execution context, including the\n * sender of the transaction and its data. While these are generally available\n * via msg.sender and msg.data, they should not be accessed in such a direct\n * manner, since when dealing with meta-transactions the account sending and\n * paying for execution may not be the actual sender (as far as an application\n * is concerned).\n *\n * This contract is only required for intermediate, library-like contracts.\n */\nabstract contract Context {\n    function _msgSender() internal view virtual returns (address) {\n        return msg.sender;\n    }\n\n    function _msgData() internal view virtual returns (bytes calldata) {\n        return msg.data;\n    }\n\n    function _contextSuffixLength() internal view virtual returns (uint256) {\n        return 0;\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"openzeppelin-contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0, 0x64, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"openzeppelin-contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"}},"compilation":{"language":"Solidity","compiler":"solc","compilerVersion":"0.8.28+commit.7893614a","compilerSettings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/"]},"name":"FeeSplitter","fullyQualifiedName":"src/FeeSplitter.sol:FeeSplitter"},"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_recipients","type":"address[]","internalType":"address[]"},{"name":"_shares","type":"uint16[]","internalType":"uint16[]"}],"stateMutability":"nonpayable"},{"name":"CallFailed","type":"error","inputs":[{"name":"recipient","type":"address","internalType":"address"}]},{"name":"InvalidLengths","type":"error","inputs":[]},{"name":"NoBalance","type":"error","inputs":[{"name":"token","type":"address","internalType":"contract IERC20"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"claim","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimERC20","type":"function","inputs":[{"name":"_tokens","type":"address[]","internalType":"contract IERC20[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"recipients","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRecipients","type":"function","inputs":[{"name":"_recipients","type":"address[]","internalType":"address[]"},{"name":"_shares","type":"uint16[]","internalType":"uint16[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"shares","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"totalShares","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":{"compiler":{"version":"0.8.28+commit.7893614a"},"language":"Solidity","output":{"abi":[{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint16[]","name":"_shares","type":"uint16[]"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"CallFailed","type":"error"},{"inputs":[],"name":"InvalidLengths","type":"error"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"NoBalance","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20[]","name":"_tokens","type":"address[]"}],"name":"claimERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"recipients","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"_recipients","type":"address[]"},{"internalType":"uint16[]","name":"_shares","type":"uint16[]"}],"name":"setRecipients","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shares","outputs":[{"internalType":"uint16","name":"","type":"uint16"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}],"devdoc":{"errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}]},"kind":"dev","methods":{"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."},"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":{"src/FeeSplitter.sol":"FeeSplitter"},"evmVersion":"cancun","libraries":{},"metadata":{"appendCBOR":false,"bytecodeHash":"none"},"optimizer":{"enabled":true,"runs":200},"remappings":[":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",":forge-std/=lib/forge-std/src/",":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/"],"viaIR":true},"sources":{"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"keccak256":"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb","license":"MIT","urls":["bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6","dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"keccak256":"0xc15298eb2b9ba5e18a8c9d12f93ad17a3e162a5c1d9b85f54c8adb5827b0d4da","license":"MIT","urls":["bzz-raw://1f3c3d8f81d2daf1231890a6a2f897be365d6a479b53dcd52ec2527b5d3faf41","dweb:/ipfs/QmeNdkd6u4at9pd2GAyyqxzrVGGvxfLpGmAKnFoYM5ya2e"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"keccak256":"0x81b022028c39007cce9920c394b9cddd1cb9f3a1c0398f254b4a6492df92ad2b","license":"MIT","urls":["bzz-raw://e0b61b8a5c69b4df993c3d6f94c174ab293aa8698d149bce7be2d88f82929beb","dweb:/ipfs/QmbtacmB1k8ginfrHvAJpjVeqnjYGfXYrkXmMPYEb83z4t"]},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"keccak256":"0xb5d81383d40f4006d1ce4bbad0064e7a930e17302cbe2a745e09cb403f042733","license":"MIT","urls":["bzz-raw://3fc4a5681c2f00f41f49260a36ae6bbe1121dd93d470ea24d51d556eff2980be","dweb:/ipfs/QmUBW6TwVWtGP96ka9TfuGivd27kH8CtkXD8RQAAecSFiR"]},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"keccak256":"0xfe37358f223eddd65d61bb62b0b7bdb69d7101b5ec8d484292b8c1583a153b8a","license":"MIT","urls":["bzz-raw://28dd43f30af3c12ae0fc08dd031b1250e906ef3c95f63f30fac6fd15aee2a662","dweb:/ipfs/QmUkSyWsSRx36w1ti7U6qnGnQgJq16wpMhjeJrnyn9AXwG"]},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"keccak256":"0x1183b415155c1a7bf56d45edad5b17caf0da70935ac420698cbe8afb6750cbb2","license":"MIT","urls":["bzz-raw://21d9edaeb3e5e8f93eb0fdab41530654e8169b1990b3bbfcf5e4527c52aa03f5","dweb:/ipfs/QmWrqpNW3x5k3pTjvrT8XU1hauHnXTjqaPL2tfzMuWYosj"]},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"keccak256":"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2","license":"MIT","urls":["bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12","dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF"]},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"keccak256":"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3","license":"MIT","urls":["bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a","dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA"]},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"keccak256":"0x4ee0e04cc52827588793a141d5efb9830f179a17e80867cc332b3a30ceb30fd9","license":"MIT","urls":["bzz-raw://17d8f47fce493b34099ed9005c5aee3012488f063cfe1c34ed8f9e6fc3d576e5","dweb:/ipfs/QmZco2GbZZhEMvG3BovyoGMAFKvfi2LhfNGQLn283LPrXf"]},"src/FeeSplitter.sol":{"keccak256":"0x206e4aab882cdde8058194c5079d807651be41f4d57564b295e2869c6866ba64","license":"MIT","urls":["bzz-raw://29b148cb935c00770cacefc21d27c429cfc1f2f2d97cd0b5a4fb5068ed733985","dweb:/ipfs/QmaxE6n7DNyG3qDHEmkPThB4eSeiPLxN536aVuDfVqwFK3"]}},"version":1},"storageLayout":{"types":{"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint16)dyn_storage":{"base":"t_uint16","label":"uint16[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_array(t_address)dyn_storage":{"base":"t_address","label":"address[]","encoding":"dynamic_array","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"1","type":"t_uint256","astId":811,"label":"_status","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"2","type":"t_array(t_address)dyn_storage","astId":913,"label":"recipients","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"3","type":"t_array(t_uint16)dyn_storage","astId":916,"label":"shares","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"4","type":"t_uint256","astId":918,"label":"totalShares","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"}]},"transientStorageLayout":null,"userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"methods":{"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."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"sourceIds":{"src/FeeSplitter.sol":{"id":9},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":6},"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"id":0},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":4},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":1},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"id":7},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":8}},"additionalInput":null,"stdJsonInput":{"sources":{"src/FeeSplitter.sol":{"content":"// SPDX-License-Identifier: MIT\npragma solidity ^0.8.28;\n\nimport { Ownable } from \"openzeppelin-contracts/access/Ownable.sol\";\nimport { IERC20 } from \"openzeppelin-contracts/token/ERC20/IERC20.sol\";\nimport { SafeERC20 } from \"openzeppelin-contracts/token/ERC20/utils/SafeERC20.sol\";\nimport { ReentrancyGuard } from \"openzeppelin-contracts/utils/ReentrancyGuard.sol\";\n\ncontract FeeSplitter is Ownable, ReentrancyGuard {\n    using SafeERC20 for IERC20;\n\n    error CallFailed(address recipient);\n    error NoBalance(IERC20 token);\n    error InvalidLengths();\n\n    address[] public recipients;\n    uint16[] public shares;\n    uint256 public totalShares;\n\n    constructor(address _owner, address[] memory _recipients, uint16[] memory _shares) Ownable(_owner) {\n        _setRecipients(_recipients, _shares);\n    }\n\n    function claim() public nonReentrant {\n        uint256 length = shares.length;\n        uint256 totalBalance = address(this).balance;\n\n        bool success = false;\n\n        for (uint256 i = 0; i < length;) {\n            (success,) = recipients[i].call{ value: (totalBalance * shares[i]) / totalShares }(\"\");\n            if (!success) {\n                revert CallFailed(recipients[i]);\n            }\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function claimERC20(IERC20[] calldata _tokens) public nonReentrant {\n        uint256 tokensLength = _tokens.length;\n        uint256 sharesLength = shares.length;\n\n        for (uint256 i = 0; i < tokensLength;) {\n            uint256 totalBalance = _tokens[i].balanceOf(address(this));\n\n            if (totalBalance == 0) {\n                revert NoBalance(_tokens[i]);\n            }\n\n            for (uint256 j = 0; j < sharesLength;) {\n                _tokens[i].safeTransfer(recipients[j], (totalBalance * shares[j]) / totalShares);\n\n                unchecked {\n                    ++j;\n                }\n            }\n\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    function setRecipients(address[] calldata _recipients, uint16[] calldata _shares) external onlyOwner {\n        _setRecipients(_recipients, _shares);\n    }\n\n    function _setRecipients(address[] memory _recipients, uint16[] memory _shares) internal {\n        uint256 length = _shares.length;\n        if (length != _recipients.length) {\n            revert InvalidLengths();\n        }\n\n        recipients = _recipients;\n        shares = _shares;\n\n        totalShares = 0;\n        for (uint256 i = 0; i < length;) {\n            totalShares += _shares[i];\n            unchecked {\n                ++i;\n            }\n        }\n    }\n\n    receive() external payable { }\n}\n"},"@openzeppelin/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\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 v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"openzeppelin-contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"@openzeppelin/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"@openzeppelin/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"openzeppelin-contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)\n\npragma solidity ^0.8.20;\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/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0, 0x64, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"@openzeppelin/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)\n\npragma solidity ^0.8.20;\n\nimport {Context} from \"../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 * The initial owner is set to the address provided by the deployer. This can\n * 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    /**\n     * @dev The caller account is not authorized to perform an operation.\n     */\n    error OwnableUnauthorizedAccount(address account);\n\n    /**\n     * @dev The owner is not a valid owner account. (eg. `address(0)`)\n     */\n    error OwnableInvalidOwner(address owner);\n\n    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);\n\n    /**\n     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.\n     */\n    constructor(address initialOwner) {\n        if (initialOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\n        _transferOwnership(initialOwner);\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        if (owner() != _msgSender()) {\n            revert OwnableUnauthorizedAccount(_msgSender());\n        }\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        if (newOwner == address(0)) {\n            revert OwnableInvalidOwner(address(0));\n        }\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"},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC20.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC20} from \"../token/ERC20/IERC20.sol\";\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.0.0) (interfaces/IERC165.sol)\n\npragma solidity >=0.4.16;\n\nimport {IERC165} from \"../utils/introspection/IERC165.sol\";\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-20 standard as defined in the ERC.\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 value of tokens in existence.\n     */\n    function totalSupply() external view returns (uint256);\n\n    /**\n     * @dev Returns the value of tokens owned by `account`.\n     */\n    function balanceOf(address account) external view returns (uint256);\n\n    /**\n     * @dev Moves a `value` amount of 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 value) 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 a `value` amount of tokens as the allowance of `spender` over the\n     * 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 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the\n     * allowance mechanism. `value` 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 value) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/IERC1363.sol)\n\npragma solidity >=0.6.2;\n\nimport {IERC20} from \"./IERC20.sol\";\nimport {IERC165} from \"./IERC165.sol\";\n\n/**\n * @title IERC1363\n * @dev Interface of the ERC-1363 standard as defined in the https://eips.ethereum.org/EIPS/eip-1363[ERC-1363].\n *\n * Defines an extension interface for ERC-20 tokens that supports executing code on a recipient contract\n * after `transfer` or `transferFrom`, or code on a spender contract after `approve`, in a single transaction.\n */\ninterface IERC1363 is IERC20, IERC165 {\n    /*\n     * Note: the ERC-165 identifier for this interface is 0xb0202a11.\n     * 0xb0202a11 ===\n     *   bytes4(keccak256('transferAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('transferAndCall(address,uint256,bytes)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256)')) ^\n     *   bytes4(keccak256('transferFromAndCall(address,address,uint256,bytes)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256)')) ^\n     *   bytes4(keccak256('approveAndCall(address,uint256,bytes)'))\n     */\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from the caller's account to `to`\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferAndCall(address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value) external returns (bool);\n\n    /**\n     * @dev Moves a `value` amount of tokens from `from` to `to` using the allowance mechanism\n     * and then calls {IERC1363Receiver-onTransferReceived} on `to`.\n     * @param from The address which you want to send tokens from.\n     * @param to The address which you want to transfer to.\n     * @param value The amount of tokens to be transferred.\n     * @param data Additional data with no specified format, sent in call to `to`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function transferFromAndCall(address from, address to, uint256 value, bytes calldata data) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value) external returns (bool);\n\n    /**\n     * @dev Sets a `value` amount of tokens as the allowance of `spender` over the\n     * caller's tokens and then calls {IERC1363Spender-onApprovalReceived} on `spender`.\n     * @param spender The address which will spend the funds.\n     * @param value The amount of tokens to be spent.\n     * @param data Additional data with no specified format, sent in call to `spender`.\n     * @return A boolean value indicating whether the operation succeeded unless throwing.\n     */\n    function approveAndCall(address spender, uint256 value, bytes calldata data) external returns (bool);\n}\n"},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)\n\npragma solidity ^0.8.20;\n\n/**\n * @dev Contract module that helps prevent reentrant calls to a function.\n *\n * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier\n * available, which can be applied to functions to make sure there are no nested\n * (reentrant) calls to them.\n *\n * Note that because there is a single `nonReentrant` guard, functions marked as\n * `nonReentrant` may not call one another. This can be worked around by making\n * those functions `private`, and then adding `external` `nonReentrant` entry\n * points to them.\n *\n * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,\n * consider using {ReentrancyGuardTransient} instead.\n *\n * TIP: If you would like to learn more about reentrancy and alternative ways\n * to protect against it, check out our blog post\n * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].\n */\nabstract contract ReentrancyGuard {\n    // Booleans are more expensive than uint256 or any type that takes up a full\n    // word because each write operation emits an extra SLOAD to first read the\n    // slot's contents, replace the bits taken up by the boolean, and then write\n    // back. This is the compiler's defense against contract upgrades and\n    // pointer aliasing, and it cannot be disabled.\n\n    // The values being non-zero value makes deployment a bit more expensive,\n    // but in exchange the refund on every call to nonReentrant will be lower in\n    // amount. Since refunds are capped to a percentage of the total\n    // transaction's gas, it is best to keep them low in cases like this one, to\n    // increase the likelihood of the full refund coming into effect.\n    uint256 private constant NOT_ENTERED = 1;\n    uint256 private constant ENTERED = 2;\n\n    uint256 private _status;\n\n    /**\n     * @dev Unauthorized reentrant call.\n     */\n    error ReentrancyGuardReentrantCall();\n\n    constructor() {\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Prevents a contract from calling itself, directly or indirectly.\n     * Calling a `nonReentrant` function from another `nonReentrant`\n     * function is not supported. It is possible to prevent this from happening\n     * by making the `nonReentrant` function external, and making it call a\n     * `private` function that does the actual work.\n     */\n    modifier nonReentrant() {\n        _nonReentrantBefore();\n        _;\n        _nonReentrantAfter();\n    }\n\n    function _nonReentrantBefore() private {\n        // On the first call to nonReentrant, _status will be NOT_ENTERED\n        if (_status == ENTERED) {\n            revert ReentrancyGuardReentrantCall();\n        }\n\n        // Any calls to nonReentrant after this point will fail\n        _status = ENTERED;\n    }\n\n    function _nonReentrantAfter() private {\n        // By storing the original value once again, a refund is triggered (see\n        // https://eips.ethereum.org/EIPS/eip-2200)\n        _status = NOT_ENTERED;\n    }\n\n    /**\n     * @dev Returns true if the reentrancy guard is currently set to \"entered\", which indicates there is a\n     * `nonReentrant` function in the call stack.\n     */\n    function _reentrancyGuardEntered() internal view returns (bool) {\n        return _status == ENTERED;\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.3.0) (token/ERC20/utils/SafeERC20.sol)\n\npragma solidity ^0.8.20;\n\nimport {IERC20} from \"../IERC20.sol\";\nimport {IERC1363} from \"../../../interfaces/IERC1363.sol\";\n\n/**\n * @title SafeERC20\n * @dev Wrappers around ERC-20 operations that throw on failure (when the token\n * contract returns false). Tokens that return no value (and instead revert or\n * throw on failure) are also supported, non-reverting calls are assumed to be\n * successful.\n * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,\n * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.\n */\nlibrary SafeERC20 {\n    /**\n     * @dev An operation with an ERC-20 token failed.\n     */\n    error SafeERC20FailedOperation(address token);\n\n    /**\n     * @dev Indicates a failed `decreaseAllowance` request.\n     */\n    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);\n\n    /**\n     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     */\n    function safeTransfer(IERC20 token, address to, uint256 value) internal {\n        if (!_safeTransfer(token, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the\n     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.\n     */\n    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {\n        if (!_safeTransferFrom(token, from, to, value, true)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Variant of {safeTransfer} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransfer(IERC20 token, address to, uint256 value) internal returns (bool) {\n        return _safeTransfer(token, to, value, false);\n    }\n\n    /**\n     * @dev Variant of {safeTransferFrom} that returns a bool instead of reverting if the operation is not successful.\n     */\n    function trySafeTransferFrom(IERC20 token, address from, address to, uint256 value) internal returns (bool) {\n        return _safeTransferFrom(token, from, to, value, false);\n    }\n\n    /**\n     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {\n        uint256 oldAllowance = token.allowance(address(this), spender);\n        forceApprove(token, spender, oldAllowance + value);\n    }\n\n    /**\n     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no\n     * value, non-reverting calls are assumed to be successful.\n     *\n     * IMPORTANT: If the token implements ERC-7674 (ERC-20 with temporary allowance), and if the \"client\"\n     * smart contract uses ERC-7674 to set temporary allowances, then the \"client\" smart contract should avoid using\n     * this function. Performing a {safeIncreaseAllowance} or {safeDecreaseAllowance} operation on a token contract\n     * that has a non-zero temporary allowance (for that particular owner-spender) will result in unexpected behavior.\n     */\n    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {\n        unchecked {\n            uint256 currentAllowance = token.allowance(address(this), spender);\n            if (currentAllowance < requestedDecrease) {\n                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);\n            }\n            forceApprove(token, spender, currentAllowance - requestedDecrease);\n        }\n    }\n\n    /**\n     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,\n     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval\n     * to be set to zero before setting it to a non-zero value, such as USDT.\n     *\n     * NOTE: If the token implements ERC-7674, this function will not modify any temporary allowance. This function\n     * only sets the \"standard\" allowance. Any temporary allowance will remain active, in addition to the value being\n     * set here.\n     */\n    function forceApprove(IERC20 token, address spender, uint256 value) internal {\n        if (!_safeApprove(token, spender, value, false)) {\n            if (!_safeApprove(token, spender, 0, true)) revert SafeERC20FailedOperation(address(token));\n            if (!_safeApprove(token, spender, value, true)) revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferAndCall, with a fallback to the simple {ERC20} transfer if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            safeTransfer(token, to, value);\n        } else if (!token.transferAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} transferFromAndCall, with a fallback to the simple {ERC20} transferFrom if the target\n     * has no code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function transferFromAndCallRelaxed(\n        IERC1363 token,\n        address from,\n        address to,\n        uint256 value,\n        bytes memory data\n    ) internal {\n        if (to.code.length == 0) {\n            safeTransferFrom(token, from, to, value);\n        } else if (!token.transferFromAndCall(from, to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Performs an {ERC1363} approveAndCall, with a fallback to the simple {ERC20} approve if the target has no\n     * code. This can be used to implement an {ERC721}-like safe transfer that rely on {ERC1363} checks when\n     * targeting contracts.\n     *\n     * NOTE: When the recipient address (`to`) has no code (i.e. is an EOA), this function behaves as {forceApprove}.\n     * Opposedly, when the recipient address (`to`) has code, this function only attempts to call {ERC1363-approveAndCall}\n     * once without retrying, and relies on the returned value to be true.\n     *\n     * Reverts if the returned value is other than `true`.\n     */\n    function approveAndCallRelaxed(IERC1363 token, address to, uint256 value, bytes memory data) internal {\n        if (to.code.length == 0) {\n            forceApprove(token, to, value);\n        } else if (!token.approveAndCall(to, value, data)) {\n            revert SafeERC20FailedOperation(address(token));\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transfer(to, value)` call, relaxing the requirement on the return value: the\n     * return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransfer(IERC20 token, address to, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.transfer.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(to, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.transferFrom(from, to, value)` call, relaxing the requirement on the return\n     * value: the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param from The sender of the tokens\n     * @param to The recipient of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeTransferFrom(\n        IERC20 token,\n        address from,\n        address to,\n        uint256 value,\n        bool bubble\n    ) private returns (bool success) {\n        bytes4 selector = IERC20.transferFrom.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(from, shr(96, not(0))))\n            mstore(0x24, and(to, shr(96, not(0))))\n            mstore(0x44, value)\n            success := call(gas(), token, 0, 0, 0x64, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n            mstore(0x60, 0)\n        }\n    }\n\n    /**\n     * @dev Imitates a Solidity `token.approve(spender, value)` call, relaxing the requirement on the return value:\n     * the return value is optional (but if data is returned, it must not be false).\n     *\n     * @param token The token targeted by the call.\n     * @param spender The spender of the tokens\n     * @param value The amount of token to transfer\n     * @param bubble Behavior switch if the transfer call reverts: bubble the revert reason or return a false boolean.\n     */\n    function _safeApprove(IERC20 token, address spender, uint256 value, bool bubble) private returns (bool success) {\n        bytes4 selector = IERC20.approve.selector;\n\n        assembly (\"memory-safe\") {\n            let fmp := mload(0x40)\n            mstore(0x00, selector)\n            mstore(0x04, and(spender, shr(96, not(0))))\n            mstore(0x24, value)\n            success := call(gas(), token, 0, 0, 0x44, 0, 0x20)\n            // if call success and return is true, all is good.\n            // otherwise (not success or return is not true), we need to perform further checks\n            if iszero(and(success, eq(mload(0x00), 1))) {\n                // if the call was a failure and bubble is enabled, bubble the error\n                if and(iszero(success), bubble) {\n                    returndatacopy(fmp, 0, returndatasize())\n                    revert(fmp, returndatasize())\n                }\n                // if the return value is not true, then the call is only successful if:\n                // - the token address has code\n                // - the returndata is empty\n                success := and(success, and(iszero(returndatasize()), gt(extcodesize(token), 0)))\n            }\n            mstore(0x40, fmp)\n        }\n    }\n}\n"},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"content":"// SPDX-License-Identifier: MIT\n// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)\n\npragma solidity >=0.4.16;\n\n/**\n * @dev Interface of the ERC-165 standard, as defined in the\n * https://eips.ethereum.org/EIPS/eip-165[ERC].\n *\n * Implementers can declare support of contract interfaces, which can then be\n * queried by others ({ERC165Checker}).\n *\n * For an implementation, see {ERC165}.\n */\ninterface IERC165 {\n    /**\n     * @dev Returns true if this contract implements the interface defined by\n     * `interfaceId`. See the corresponding\n     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]\n     * to learn more about how these ids are created.\n     *\n     * This function call must use less than 30 000 gas.\n     */\n    function supportsInterface(bytes4 interfaceId) external view returns (bool);\n}\n"}},"language":"Solidity","settings":{"viaIR":true,"metadata":{"appendCBOR":false,"bytecodeHash":"none","useLiteralContent":false},"libraries":{},"optimizer":{"runs":200,"enabled":true},"evmVersion":"cancun","remappings":["openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/","@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/","erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/","forge-std/=lib/forge-std/src/","halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/"]}},"stdJsonOutput":{"sources":{"src/FeeSplitter.sol":{"id":9},"lib/openzeppelin-contracts/contracts/utils/Context.sol":{"id":6},"lib/openzeppelin-contracts/contracts/access/Ownable.sol":{"id":0},"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol":{"id":3},"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol":{"id":2},"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol":{"id":4},"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol":{"id":1},"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol":{"id":7},"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol":{"id":5},"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol":{"id":8}},"contracts":{"src/FeeSplitter.sol":{"FeeSplitter":{"abi":[{"type":"constructor","inputs":[{"name":"_owner","type":"address","internalType":"address"},{"name":"_recipients","type":"address[]","internalType":"address[]"},{"name":"_shares","type":"uint16[]","internalType":"uint16[]"}],"stateMutability":"nonpayable"},{"name":"CallFailed","type":"error","inputs":[{"name":"recipient","type":"address","internalType":"address"}]},{"name":"InvalidLengths","type":"error","inputs":[]},{"name":"NoBalance","type":"error","inputs":[{"name":"token","type":"address","internalType":"contract IERC20"}]},{"name":"OwnableInvalidOwner","type":"error","inputs":[{"name":"owner","type":"address","internalType":"address"}]},{"name":"OwnableUnauthorizedAccount","type":"error","inputs":[{"name":"account","type":"address","internalType":"address"}]},{"name":"ReentrancyGuardReentrantCall","type":"error","inputs":[]},{"name":"SafeERC20FailedOperation","type":"error","inputs":[{"name":"token","type":"address","internalType":"address"}]},{"name":"OwnershipTransferred","type":"event","inputs":[{"name":"previousOwner","type":"address","indexed":true,"internalType":"address"},{"name":"newOwner","type":"address","indexed":true,"internalType":"address"}],"anonymous":false},{"name":"claim","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"claimERC20","type":"function","inputs":[{"name":"_tokens","type":"address[]","internalType":"contract IERC20[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"owner","type":"function","inputs":[],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"recipients","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"address","internalType":"address"}],"stateMutability":"view"},{"name":"renounceOwnership","type":"function","inputs":[],"outputs":[],"stateMutability":"nonpayable"},{"name":"setRecipients","type":"function","inputs":[{"name":"_recipients","type":"address[]","internalType":"address[]"},{"name":"_shares","type":"uint16[]","internalType":"uint16[]"}],"outputs":[],"stateMutability":"nonpayable"},{"name":"shares","type":"function","inputs":[{"name":"","type":"uint256","internalType":"uint256"}],"outputs":[{"name":"","type":"uint16","internalType":"uint16"}],"stateMutability":"view"},{"name":"totalShares","type":"function","inputs":[],"outputs":[{"name":"","type":"uint256","internalType":"uint256"}],"stateMutability":"view"},{"name":"transferOwnership","type":"function","inputs":[{"name":"newOwner","type":"address","internalType":"address"}],"outputs":[],"stateMutability":"nonpayable"},{"type":"receive","stateMutability":"payable"}],"metadata":"{\"compiler\":{\"version\":\"0.8.28+commit.7893614a\"},\"language\":\"Solidity\",\"output\":{\"abi\":[{\"inputs\":[{\"internalType\":\"address\",\"name\":\"_owner\",\"type\":\"address\"},{\"internalType\":\"address[]\",\"name\":\"_recipients\",\"type\":\"address[]\"},{\"internalType\":\"uint16[]\",\"name\":\"_shares\",\"type\":\"uint16[]\"}],\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"}],\"name\":\"CallFailed\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"InvalidLengths\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"contract IERC20\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"NoBalance\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"}],\"name\":\"OwnableInvalidOwner\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"OwnableUnauthorizedAccount\",\"type\":\"error\"},{\"inputs\":[],\"name\":\"ReentrancyGuardReentrantCall\",\"type\":\"error\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"token\",\"type\":\"address\"}],\"name\":\"SafeERC20FailedOperation\",\"type\":\"error\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"claim\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"contract IERC20[]\",\"name\":\"_tokens\",\"type\":\"address[]\"}],\"name\":\"claimERC20\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"recipients\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address[]\",\"name\":\"_recipients\",\"type\":\"address[]\"},{\"internalType\":\"uint16[]\",\"name\":\"_shares\",\"type\":\"uint16[]\"}],\"name\":\"setRecipients\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"name\":\"shares\",\"outputs\":[{\"internalType\":\"uint16\",\"name\":\"\",\"type\":\"uint16\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[],\"name\":\"totalShares\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"stateMutability\":\"view\",\"type\":\"function\"},{\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"stateMutability\":\"payable\",\"type\":\"receive\"}],\"devdoc\":{\"errors\":{\"OwnableInvalidOwner(address)\":[{\"details\":\"The owner is not a valid owner account. (eg. `address(0)`)\"}],\"OwnableUnauthorizedAccount(address)\":[{\"details\":\"The caller account is not authorized to perform an operation.\"}],\"ReentrancyGuardReentrantCall()\":[{\"details\":\"Unauthorized reentrant call.\"}],\"SafeERC20FailedOperation(address)\":[{\"details\":\"An operation with an ERC-20 token failed.\"}]},\"kind\":\"dev\",\"methods\":{\"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.\"},\"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\":{\"src/FeeSplitter.sol\":\"FeeSplitter\"},\"evmVersion\":\"cancun\",\"libraries\":{},\"metadata\":{\"appendCBOR\":false,\"bytecodeHash\":\"none\"},\"optimizer\":{\"enabled\":true,\"runs\":200},\"remappings\":[\":@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/\",\":erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/\",\":forge-std/=lib/forge-std/src/\",\":halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/\",\":openzeppelin-contracts/=lib/openzeppelin-contracts/contracts/\"],\"viaIR\":true},\"sources\":{\"lib/openzeppelin-contracts/contracts/access/Ownable.sol\":{\"keccak256\":\"0xff6d0bb2e285473e5311d9d3caacb525ae3538a80758c10649a4d61029b017bb\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://8ed324d3920bb545059d66ab97d43e43ee85fd3bd52e03e401f020afb0b120f6\",\"dweb:/ipfs/QmfEckWLmZkDDcoWrkEvMWhms66xwTLff9DDhegYpvHo1a\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC1363.sol\":{\"keccak256\":\"0xc15298eb2b9ba5e18a8c9d12f93ad17a3e162a5c1d9b85f54c8adb5827b0d4da\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://1f3c3d8f81d2daf1231890a6a2f897be365d6a479b53dcd52ec2527b5d3faf41\",\"dweb:/ipfs/QmeNdkd6u4at9pd2GAyyqxzrVGGvxfLpGmAKnFoYM5ya2e\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC165.sol\":{\"keccak256\":\"0x81b022028c39007cce9920c394b9cddd1cb9f3a1c0398f254b4a6492df92ad2b\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://e0b61b8a5c69b4df993c3d6f94c174ab293aa8698d149bce7be2d88f82929beb\",\"dweb:/ipfs/QmbtacmB1k8ginfrHvAJpjVeqnjYGfXYrkXmMPYEb83z4t\"]},\"lib/openzeppelin-contracts/contracts/interfaces/IERC20.sol\":{\"keccak256\":\"0xb5d81383d40f4006d1ce4bbad0064e7a930e17302cbe2a745e09cb403f042733\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3fc4a5681c2f00f41f49260a36ae6bbe1121dd93d470ea24d51d556eff2980be\",\"dweb:/ipfs/QmUBW6TwVWtGP96ka9TfuGivd27kH8CtkXD8RQAAecSFiR\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol\":{\"keccak256\":\"0xfe37358f223eddd65d61bb62b0b7bdb69d7101b5ec8d484292b8c1583a153b8a\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://28dd43f30af3c12ae0fc08dd031b1250e906ef3c95f63f30fac6fd15aee2a662\",\"dweb:/ipfs/QmUkSyWsSRx36w1ti7U6qnGnQgJq16wpMhjeJrnyn9AXwG\"]},\"lib/openzeppelin-contracts/contracts/token/ERC20/utils/SafeERC20.sol\":{\"keccak256\":\"0x1183b415155c1a7bf56d45edad5b17caf0da70935ac420698cbe8afb6750cbb2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://21d9edaeb3e5e8f93eb0fdab41530654e8169b1990b3bbfcf5e4527c52aa03f5\",\"dweb:/ipfs/QmWrqpNW3x5k3pTjvrT8XU1hauHnXTjqaPL2tfzMuWYosj\"]},\"lib/openzeppelin-contracts/contracts/utils/Context.sol\":{\"keccak256\":\"0x493033a8d1b176a037b2cc6a04dad01a5c157722049bbecf632ca876224dd4b2\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://6a708e8a5bdb1011c2c381c9a5cfd8a9a956d7d0a9dc1bd8bcdaf52f76ef2f12\",\"dweb:/ipfs/Qmax9WHBnVsZP46ZxEMNRQpLQnrdE4dK8LehML1Py8FowF\"]},\"lib/openzeppelin-contracts/contracts/utils/ReentrancyGuard.sol\":{\"keccak256\":\"0x11a5a79827df29e915a12740caf62fe21ebe27c08c9ae3e09abe9ee3ba3866d3\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://3cf0c69ab827e3251db9ee6a50647d62c90ba580a4d7bbff21f2bea39e7b2f4a\",\"dweb:/ipfs/QmZiKwtKU1SBX4RGfQtY7PZfiapbbu6SZ9vizGQD9UHjRA\"]},\"lib/openzeppelin-contracts/contracts/utils/introspection/IERC165.sol\":{\"keccak256\":\"0x4ee0e04cc52827588793a141d5efb9830f179a17e80867cc332b3a30ceb30fd9\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://17d8f47fce493b34099ed9005c5aee3012488f063cfe1c34ed8f9e6fc3d576e5\",\"dweb:/ipfs/QmZco2GbZZhEMvG3BovyoGMAFKvfi2LhfNGQLn283LPrXf\"]},\"src/FeeSplitter.sol\":{\"keccak256\":\"0x206e4aab882cdde8058194c5079d807651be41f4d57564b295e2869c6866ba64\",\"license\":\"MIT\",\"urls\":[\"bzz-raw://29b148cb935c00770cacefc21d27c429cfc1f2f2d97cd0b5a4fb5068ed733985\",\"dweb:/ipfs/QmaxE6n7DNyG3qDHEmkPThB4eSeiPLxN536aVuDfVqwFK3\"]}},\"version\":1}","userdoc":{"kind":"user","methods":{},"version":1},"devdoc":{"kind":"dev","errors":{"OwnableInvalidOwner(address)":[{"details":"The owner is not a valid owner account. (eg. `address(0)`)"}],"ReentrancyGuardReentrantCall()":[{"details":"Unauthorized reentrant call."}],"SafeERC20FailedOperation(address)":[{"details":"An operation with an ERC-20 token failed."}],"OwnableUnauthorizedAccount(address)":[{"details":"The caller account is not authorized to perform an operation."}]},"methods":{"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."},"transferOwnership(address)":{"details":"Transfers ownership of the contract to a new account (`newOwner`). Can only be called by the current owner."}},"version":1},"storageLayout":{"types":{"t_uint16":{"label":"uint16","encoding":"inplace","numberOfBytes":"2"},"t_address":{"label":"address","encoding":"inplace","numberOfBytes":"20"},"t_uint256":{"label":"uint256","encoding":"inplace","numberOfBytes":"32"},"t_array(t_uint16)dyn_storage":{"base":"t_uint16","label":"uint16[]","encoding":"dynamic_array","numberOfBytes":"32"},"t_array(t_address)dyn_storage":{"base":"t_address","label":"address[]","encoding":"dynamic_array","numberOfBytes":"32"}},"storage":[{"slot":"0","type":"t_address","astId":8,"label":"_owner","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"1","type":"t_uint256","astId":811,"label":"_status","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"2","type":"t_array(t_address)dyn_storage","astId":913,"label":"recipients","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"3","type":"t_array(t_uint16)dyn_storage","astId":916,"label":"shares","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"},{"slot":"4","type":"t_uint256","astId":918,"label":"totalShares","offset":0,"contract":"src/FeeSplitter.sol:FeeSplitter"}]},"transientStorageLayout":null,"evm":{"bytecode":{"object":"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","sourceMap":"368:2289:9:-:0;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;:::i;:::-;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;368:2289:9;1273:26:0;;1269:95;;-1:-1:-1;368:2289:9;;-1:-1:-1;;;;;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;3052:40:0;;-1:-1:-1;3052:40:0;1857:1:7;;;368:2289:9;;;;;2297:28;;2293:82;;368:2289;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;2385:24;368:2289;;2385:24;368:2289;;;;;;;;2385:24;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;-1:-1:-1;368:2289:9;;;;;;-1:-1:-1;;368:2289:9;;;;-1:-1:-1;;;;;;;368:2289:9;;;;;;;;;2419:16;368:2289;;2419:16;368:2289;;;;;;;;;2419:16;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;;-1:-1:-1;;;368:2289:9;;;;;;;;1857:1:7;;;;-1:-1:-1;368:2289:9;1857:1:7;-1:-1:-1;2491:10:9;;;;;;368:2289;;;;;;;;;2476:13;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;1857:1:7;;368:2289:9;1857:1:7;368:2289:9;2476:13;;368:2289;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;-1:-1:-1;368:2289:9;-1:-1:-1;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;1857:1:7;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;-1:-1:-1;368:2289:9;;;;1857:1:7;368:2289:9;;;;;;;;;1857:1:7;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;2419:16;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;;;;;;;;;;1857:1:7;368:2289:9;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;368:2289:9;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;1857:1:7;368:2289:9;;;;2385:24;-1:-1:-1;368:2289:9;;;;;;;;;;;:::i;:::-;;;;2293:82;2348:16;;;-1:-1:-1;2348:16:9;;-1:-1:-1;2348:16:9;1269:95:0;1322:31;;;-1:-1:-1;1322:31:0;-1:-1:-1;1322:31:0;368:2289:9;;-1:-1:-1;1322:31:0;368:2289:9;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;:::o;:::-;;;-1:-1:-1;;;;;368:2289:9;;;;;;:::o;:::-;-1:-1:-1;;;;;368:2289:9;;;;;;;;;:::o;:::-;;;;;;;;:::o;:::-;;;;;;;","linkReferences":{}},"deployedBytecode":{"object":"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","sourceMap":"368:2289:9:-:0;;;;;;;;;;-1:-1:-1;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;1500:62:0;;:::i;:::-;2627:22;;2623:91;;368:2289:9;;;-1:-1:-1;;;;;;368:2289:9;;;;;;-1:-1:-1;;;;;368:2289:9;;3052:40:0;;368:2289:9;3052:40:0;368:2289:9;2623:91:0;2672:31;;;368:2289:9;2672:31:0;368:2289:9;;;;;2672:31:0;368:2289:9;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;;;;;;:::i;:::-;2466:103:7;;:::i;:::-;1440:6:9;368:2289;;1484:16;;;;;;1338:4:5;1899:1:7;;368:2289:9;1469:13;8539:1058:5;368:2289:9;-1:-1:-1;;;;;1540:10:9;;;;;;:::i;:::-;;:::i;:::-;368:2289;;;;;;;;;;1540:35;;1569:4;368:2289;1540:35;;368:2289;1540:35;;;;;;;368:2289;1540:35;;;1469:13;1594:17;;;1590:84;;368:2289;1708:16;;;;;;368:2289;;1338:4:5;368:2289:9;1469:13;;1693;1745:10;;;;;;;;;;;:::i;:::-;1769:13;;;:::i;:::-;368:2289;;1440:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;1784:40;1785:24;368:2289;1800:9;;;:::i;:::-;368:2289;;;1440:6;368:2289;;;1785:24;;:::i;:::-;368:2289;;1784:40;;:::i;:::-;368:2289;8539:1058:5;8504:24;;;;368:2289:9;8539:1058:5;368:2289:9;8539:1058:5;;;368:2289:9;;8539:1058:5;;;;;;;1338:4;368:2289:9;8539:1058:5;;;;;;;1693:13:9;368:2289;8539:1058:5;1305:38;1301:116;;368:2289:9;1338:4:5;368:2289:9;1693:13;;;;;;;;1301:116:5;-1:-1:-1;;;368:2289:9;1366:40:5;;;-1:-1:-1;;;;;368:2289:9;;;;;;8539:1058:5;;1366:40;8539:1058;;1338:4;8539:1058;;;;;;;;;;;;;;;;;;;368:2289:9;8539:1058:5;;;;;1590:84:9;1648:10;;;;;;:::i;:::-;-1:-1:-1;;;368:2289:9;1638:21;;;-1:-1:-1;;;;;368:2289:9;;;;;;8539:1058:5;;1638:21:9;1540:35;;;368:2289;1540:35;;;;;;;;;368:2289;1540:35;;;:::i;:::-;;;368:2289;;;;;1540:35;;;;;;-1:-1:-1;1540:35:9;;;368:2289;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;561:27;368:2289;561:27;;;;;;368:2289;561:27;;:::i;:::-;368:2289;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;1500:62:0;;;;:::i;:::-;368:2289:9;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2297:28;;2293:82;;368:2289;;;;;;;-1:-1:-1;;;368:2289:9;;;;2385:24;368:2289;;2385:24;368:2289;;;;;;;;2385:24;368:2289;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;2419:16;368:2289;;2419:16;368:2289;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;;-1:-1:-1;;;368:2289:9;;;;;;;;1899:1:7;;;368:2289:9;;1899:1:7;368:2289:9;2491:10;;;;;;368:2289;2476:13;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1899:1:7;368:2289:9;1899:1:7;368:2289:9;2476:13;;368:2289;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;-1:-1:-1;;;;;;;;;;;368:2289:9;;:::i;:::-;;;;;;;;;;;;;;;;;2419:16;368:2289;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;2293:82;2348:16;;;368:2289;2348:16;368:2289;;2348:16;368:2289;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;-1:-1:-1;;;;;368:2289:9;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;1500:62:0;;:::i;:::-;368:2289:9;;;-1:-1:-1;;;;;;368:2289:9;;;;-1:-1:-1;;;;;368:2289:9;3052:40:0;368:2289:9;;3052:40:0;368:2289:9;;;;;;;-1:-1:-1;;368:2289:9;;;;;;594:22;368:2289;594:22;;;;;368:2289;594:22;368:2289;594:22;;:::i;:::-;368:2289;;;594:22;368:2289;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;2466:103:7;;:::i;:::-;877:6:9;368:2289;923:21;368:2289;1006:10;;;;;;368:2289;1899:1:7;;368:2289:9;991:13;368:2289;1046:13;;;;;;:::i;:::-;368:2289;;877:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;1073:40;1074:24;368:2289;1089:9;;;:::i;:::-;368:2289;;;877:6;368:2289;;;1074:24;;:::i;1073:40::-;1046:73;;;368:2289;;;;;;;;;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;:::i;:::-;;;;;;;;;;1137:8;1133:79;;368:2289;;991:13;;1133:79;1183:13;;;:::i;:::-;368:2289;;-1:-1:-1;;;368:2289:9;1172:25;;;877:6;368:2289;;;;;-1:-1:-1;;;;;368:2289:9;;;;;1172:25;368:2289;;;;;;;;;-1:-1:-1;;368:2289:9;;;;;;;;;;;;;877:6;368:2289;;;;;;877:6;-1:-1:-1;368:2289:9;;;;;-1:-1:-1;;;;;;;;;;;368:2289:9;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;1046:10;368:2289;;;;;;1046:10;-1:-1:-1;368:2289:9;;-1:-1:-1;368:2289:9;;;-1:-1:-1;368:2289:9;:::o;:::-;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;:::o;:::-;;-1:-1:-1;;;;;368:2289:9;;;;;;;:::o;2575:307:7:-;1899:1;2702:7;368:2289:9;2702:18:7;2698:86;;1899:1;2702:7;1899:1;2575:307::o;2698:86::-;2743:30;;;-1:-1:-1;2743:30:7;;-1:-1:-1;2743:30:7;1796:162:0;1710:6;368:2289:9;-1:-1:-1;;;;;368:2289:9;735:10:6;1855:23:0;1851:101;;1796:162::o;1851:101::-;1901:40;;;1710:6;1901:40;735:10:6;1901:40:0;368:2289:9;;1710:6:0;1901:40;368:2289:9;;;;;;;;:::o;:::-;;;;;;;","linkReferences":{},"immutableReferences":{}}}}}}},"signatures":{"function":[{"signature":"claim()","signatureHash4":"0x4e71d92d","signatureHash32":"0x4e71d92d1cab44b435a6dcbe7dcfe75cf72953916cfa3842f5057ce194aa60e2"},{"signature":"claimERC20(address[])","signatureHash4":"0xd512143e","signatureHash32":"0xd512143ee43ca6c5d6531f3728682106ca8ee18f24941d95eed501ed9e5322f8"},{"signature":"owner()","signatureHash4":"0x8da5cb5b","signatureHash32":"0x8da5cb5b36e7f68c1d2e56001220cdbdd3ba2616072f718acfda4a06441a807d"},{"signature":"recipients(uint256)","signatureHash4":"0xd1bc76a1","signatureHash32":"0xd1bc76a1363f8ea5a66fb3b3c35fe9acfc68f5fc116613a3e876e664fe642bdf"},{"signature":"renounceOwnership()","signatureHash4":"0x715018a6","signatureHash32":"0x715018a616b5f2044428f6fadb7deef4ce9ca76ef60ea57978964ad137bbe7ae"},{"signature":"setRecipients(address[],uint16[])","signatureHash4":"0xbc45dad0","signatureHash32":"0xbc45dad09badecb68140e1cce7951b0b8bb1295554686b304a7da9bd8871853e"},{"signature":"shares(uint256)","signatureHash4":"0x57a858fc","signatureHash32":"0x57a858fc88376f76ee056b5eb7959a2f357ea36aaf452c19d7e1d7e572e21b2e"},{"signature":"totalShares()","signatureHash4":"0x3a98ef39","signatureHash32":"0x3a98ef39d75a0463a589a77e7570097b7e407deab0b5678402f964703022acc1"},{"signature":"transferOwnership(address)","signatureHash4":"0xf2fde38b","signatureHash32":"0xf2fde38b092330466c661fc723d5289b90272a3e580e3187d1d7ef788506c557"}],"event":[{"signature":"OwnershipTransferred(address,address)","signatureHash4":"0x8be0079c","signatureHash32":"0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0"}],"error":[{"signature":"CallFailed(address)","signatureHash4":"0x201be191","signatureHash32":"0x201be1916f0d160ea57f93e084f566601e51e409dbb48d368504077b3ecae393"},{"signature":"InvalidLengths()","signatureHash4":"0x1df89e8b","signatureHash32":"0x1df89e8b3406d8bcdf009bc1b4974f02af0690a82fd7f1b283dfd1d7ac6fe552"},{"signature":"NoBalance(address)","signatureHash4":"0x8cb85f52","signatureHash32":"0x8cb85f52e2272c0d10b274d000c15d3c93eca8a43d7b7c83ddb25583f9dacd83"},{"signature":"OwnableInvalidOwner(address)","signatureHash4":"0x1e4fbdf7","signatureHash32":"0x1e4fbdf7f3ef8bcaa855599e3abf48b232380f183f08f6f813d9ffa5bd585188"},{"signature":"OwnableUnauthorizedAccount(address)","signatureHash4":"0x118cdaa7","signatureHash32":"0x118cdaa7a341953d1887a2245fd6665d741c67c8c50581daa59e1d03373fa188"},{"signature":"ReentrancyGuardReentrantCall()","signatureHash4":"0x3ee5aeb5","signatureHash32":"0x3ee5aeb571de7fc460830b4d0017439a1ca56fb0bc39062227ade4fe4a24c1ca"},{"signature":"SafeERC20FailedOperation(address)","signatureHash4":"0x5274afe7","signatureHash32":"0x5274afe73c98b4749fc91ffae6b7b574e7842cb2144a159e9377a5f20b32edf9"}]},"proxyResolution":{"isProxy":false,"proxyType":null,"implementations":[]},"match":"match","chainId":"1","address":"0x79F35ed4d1f6Ba12d617C2C976d0919D4c415a87"}