ETH Price: $2,971.39 (+6.76%)

Transaction Decoder

Block:
22884581 at Jul-09-2025 10:24:47 PM +UTC
Transaction Fee:
0.001421854634008607 ETH $4.22
Gas Used:
317,741 Gas / 4.474885627 Gwei

Emitted Events:

45 WETH9.Deposit( dst=0x2905d7e4D048d29954F81b02171DD313F457a4a4, wad=40000000000000000 )
46 WETH9.Transfer( src=0x2905d7e4D048d29954F81b02171DD313F457a4a4, dst=UniswapV2Pair, wad=40000000000000000 )
47 WBTC.Transfer( from=UniswapV2Pair, to=0x2905d7e4D048d29954F81b02171DD313F457a4a4, value=99488 )
48 UniswapV2Pair.Sync( reserve0=13768801654, reserve1=5519262959232065219433 )
49 UniswapV2Pair.Swap( sender=0x2905d7e4D048d29954F81b02171DD313F457a4a4, amount0In=0, amount1In=40000000000000000, amount0Out=99488, amount1Out=0, to=0x2905d7e4D048d29954F81b02171DD313F457a4a4 )
50 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x0000000000000000000000002912868c7ac9b14dd3f64ec1713cbd8f44a17dfd, 0x0000000000000000000000002905d7e4d048d29954f81b02171dd313f457a4a4, 0000000000000000000000000000000000000000000000000000000000018894 )
51 WBTC.Transfer( from=0x2905d7e4D048d29954F81b02171DD313F457a4a4, to=UniswapV3Pool, value=99488 )
52 UniswapV3Pool.Swap( sender=0x2905d7e4D048d29954F81b02171DD313F457a4a4, recipient=0x2905d7e4D048d29954F81b02171DD313F457a4a4, amount0=-100500, amount1=99488, sqrtPriceX96=78709471490224330800206635245, liquidity=51068215199, tick=-132 )
53 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x0000000000000000000000002905d7e4d048d29954f81b02171dd313f457a4a4, 0x0000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae, 0000000000000000000000000000000000000000000000000000000000018894 )
54 0x2905d7e4d048d29954f81b02171dd313f457a4a4.0xbbb02a24579dc2e59c1609253b6ddab5457ba00895b3eda80dd41e03e2cd7e55( 0xbbb02a24579dc2e59c1609253b6ddab5457ba00895b3eda80dd41e03e2cd7e55, 0x000000000000000000000000ad27827c312cd5e71311d68e180a9872d42de23d, 0x000000000000000000000000eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee, 0x0000000000000000000000000000000000000000000000000000000000000000, 0000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae, 000000000000000000000000004e9c3ef86bc1ca1f0bb5c7662861ee93350568, 000000000000000000000000000000000000000000000000008e1bc9bf040000, 0000000000000000000000000000000000000000000000000000000000018894, 0000000000000000000000000000000000000000000000000000000000000000 )
55 TransparentUpgradeableProxy.0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef( 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0x0000000000000000000000001231deb6f5749ef6ce6943a275a1d3e7486f4eae, 0x0000000000000000000000001a39594d1657ccec689d7d84d8de8f7652a7a036, 0000000000000000000000000000000000000000000000000000000000018894 )
56 LiFiDiamond.0x7bfdfdb5e3a3776976e53cb0607060f54c5312701c8cba1155cc4d5394440b38( 0x7bfdfdb5e3a3776976e53cb0607060f54c5312701c8cba1155cc4d5394440b38, 125cfd3db32727b64cc281ff8dd76d16dd44b8d4e26de4995c412dfde6a5471d, 000000000000000000000000ac4c6e212a361c968f1725b4d055b47e63f80b75, 0000000000000000000000000000000000000000000000000000000000000000, 000000000000000000000000004e9c3ef86bc1ca1f0bb5c7662861ee93350568, 000000000000000000000000000000000000000000000000008e1bc9bf040000, 0000000000000000000000000000000000000000000000000000000000018894, 00000000000000000000000000000000000000000000000000000000686eec2f )
57 LiFiDiamond.0x38eee76fd911eabac79da7af16053e809be0e12c8637f156e77e1af309b99537( 0x38eee76fd911eabac79da7af16053e809be0e12c8637f156e77e1af309b99537, 0x125cfd3db32727b64cc281ff8dd76d16dd44b8d4e26de4995c412dfde6a5471d, 00000000000000000000000000000000000000000000000000000000000000e0, 0000000000000000000000000000000000000000000000000000000000000120, 0000000000000000000000001a39594d1657ccec689d7d84d8de8f7652a7a036, 0000000000000000000000000000000000000000000000000000000000000000, 000000000000000000000000004e9c3ef86bc1ca1f0bb5c7662861ee93350568, 000000000000000000000000000000000000000000000000008e1bc9bf040000, 0000000000000000000000000000000000000000000000000000000000018894, 000000000000000000000000000000000000000000000000000000000000000f, 6a756d7065722e65786368616e67650000000000000000000000000000000000, 000000000000000000000000000000000000000000000000000000000000002a, 3078303030303030303030303030303030303030303030303030303030303030, 3030303030303030303000000000000000000000000000000000000000000000 )

Account State Difference:

  Address   Before After State Difference Code
0x004E9C3E...e93350568
0x1a39594D...652A7a036
0.049049610893179429 Eth
Nonce: 97
0.007627756259170822 Eth
Nonce: 99
0.041421854634008607From: 0 To: 22892026855592066050609947431602401211538835161166308139
0x2260FAC5...93bc2C599
0x2912868c...f44A17dfd
(Uniswap V3: uniBTC-WBTC 3)
0xC02aaA39...83C756Cc2 2,577,367.72194499107564623 Eth2,577,367.76194499107564623 Eth0.04
0xCEfF5175...C46dd3a58
(BuilderNet)
8.851350968216219772 Eth8.851986450216219772 Eth0.000635482

Execution Trace

0x1a39594d1657ccec689d7d84d8de8f7652a7a036.e9ae5c53( )
  • ETH 0.04 LiFiDiamond.af7060fd( )
    • ETH 0.04 GenericSwapFacetV3.swapTokensSingleV3NativeToERC20( _transactionId=125CFD3DB32727B64CC281FF8DD76D16DD44B8D4E26DE4995C412DFDE6A5471D, _integrator=jumper.exchange, _referrer=0x0000000000000000000000000000000000000000, _receiver=0x1a39594D1657cCec689D7d84D8DE8F7652A7a036, _minAmountOut=99998, _swapData=[{name:callTo, type:address, order:1, indexed:false, value:0xAC4c6e212A361c968F1725b4d055b47E63F80b75, valueString:0xAC4c6e212A361c968F1725b4d055b47E63F80b75}, {name:approveTo, type:address, order:2, indexed:false, value:0xAC4c6e212A361c968F1725b4d055b47E63F80b75, valueString:0xAC4c6e212A361c968F1725b4d055b47E63F80b75}, {name:sendingAssetId, type:address, order:3, indexed:false, value:0x0000000000000000000000000000000000000000, valueString:0x0000000000000000000000000000000000000000}, {name:receivingAssetId, type:address, order:4, indexed:false, value:0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568, valueString:0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568}, {name:fromAmount, type:uint256, order:5, indexed:false, value:40000000000000000, valueString:40000000000000000}, {name:callData, type:bytes, order:6, indexed:false, value:0x5F3BD1C8000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000000000000000000000000000008E1BC9BF0400000000000000000000000000001231DEB6F5749EF6CE6943A275A1D3E7486F4EAE000000000000000000000000004E9C3EF86BC1CA1F0BB5C7662861EE93350568000000000000000000000000000000000000000000000000000000000001869D0000000000000000000000002905D7E4D048D29954F81B02171DD313F457A4A400000000000000000000000000000000000000000000000000000000000000E000000000000000000000000000000000000000000000000000000000000001E46BE92B89000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000000000000000000000000000008E1BC9BF040000000000000000000000000000004E9C3EF86BC1CA1F0BB5C7662861EE9335056800000000000000000000000000000000000000000000000000000000000188940000000000000000000000001231DEB6F5749EF6CE6943A275A1D3E7486F4EAE00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B30301FFFF0201CEFF51756C56CEFFCA006CD410B03FFC46DD3A58C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC204C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC200CEFF51756C56CEFFCA006CD410B03FFC46DD3A58002905D7E4D048D29954F81B02171DD313F457A4A4000BB8012260FAC5E5542A773AA44FBCFEDF7C193BC2C59901FFFF012912868C7AC9B14DD3F64EC1713CBD8F44A17DFD002905D7E4D048D29954F81B02171DD313F457A4A4000000000000000000000000000000000000000000000000000000000000000000000000000000000000, valueString:0x5F3BD1C8000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000000000000000000000000000008E1BC9BF0400000000000000000000000000001231DEB6F5749EF6CE6943A275A1D3E7486F4EAE000000000000000000000000004E9C3EF86BC1CA1F0BB5C7662861EE93350568000000000000000000000000000000000000000000000000000000000001869D0000000000000000000000002905D7E4D048D29954F81B02171DD313F457A4A400000000000000000000000000000000000000000000000000000000000000E000000000000000000000000000000000000000000000000000000000000001E46BE92B89000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000000000000000000000000000008E1BC9BF040000000000000000000000000000004E9C3EF86BC1CA1F0BB5C7662861EE9335056800000000000000000000000000000000000000000000000000000000000188940000000000000000000000001231DEB6F5749EF6CE6943A275A1D3E7486F4EAE00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B30301FFFF0201CEFF51756C56CEFFCA006CD410B03FFC46DD3A58C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC204C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC200CEFF51756C56CEFFCA006CD410B03FFC46DD3A58002905D7E4D048D29954F81B02171DD313F457A4A4000BB8012260FAC5E5542A773AA44FBCFEDF7C193BC2C59901FFFF012912868C7AC9B14DD3F64EC1713CBD8F44A17DFD002905D7E4D048D29954F81B02171DD313F457A4A4000000000000000000000000000000000000000000000000000000000000000000000000000000000000}, {name:requiresDeposit, type:bool, order:7, indexed:false, value:true, valueString:True}] )
      • ETH 0.04 RedSnwapper.snwap( tokenIn=0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE, amountIn=40000000000000000, recipient=0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE, tokenOut=0x004E9C3EF86bc1ca1f0bB5C7662861Ee93350568, amountOutMin=99997, executor=0x2905d7e4D048d29954F81b02171DD313F457a4a4, executorData=0x6BE92B89000000000000000000000000EEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEEE000000000000000000000000000000000000000000000000008E1BC9BF040000000000000000000000000000004E9C3EF86BC1CA1F0BB5C7662861EE9335056800000000000000000000000000000000000000000000000000000000000188940000000000000000000000001231DEB6F5749EF6CE6943A275A1D3E7486F4EAE00000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B30301FFFF0201CEFF51756C56CEFFCA006CD410B03FFC46DD3A58C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC204C02AAA39B223FE8D0A0E5C4F27EAD9083C756CC200CEFF51756C56CEFFCA006CD410B03FFC46DD3A58002905D7E4D048D29954F81B02171DD313F457A4A4000BB8012260FAC5E5542A773AA44FBCFEDF7C193BC2C59901FFFF012912868C7AC9B14DD3F64EC1713CBD8F44A17DFD002905D7E4D048D29954F81B02171DD313F457A4A40000000000000000000000000000 ) => ( amountOut=100500 )
        • TransparentUpgradeableProxy.70a08231( )
          • uniBTC.balanceOf( account=0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE ) => ( 0 )
          • ETH 0.04 0xad27827c312cd5e71311d68e180a9872d42de23d.1cff79cd( )
            • ETH 0.04 0x2905d7e4d048d29954f81b02171dd313f457a4a4.6be92b89( )
              • TransparentUpgradeableProxy.70a08231( )
              • ETH 0.04 WETH9.CALL( )
              • WETH9.transfer( dst=0xCEfF51756c56CeFFCA006cD410B03FFC46dd3a58, wad=40000000000000000 ) => ( True )
              • UniswapV2Pair.STATICCALL( )
              • WETH9.balanceOf( 0xCEfF51756c56CeFFCA006cD410B03FFC46dd3a58 ) => ( 5519262959232065219433 )
              • UniswapV2Pair.swap( amount0Out=99488, amount1Out=0, to=0x2905d7e4D048d29954F81b02171DD313F457a4a4, data=0x )
              • WBTC.balanceOf( _owner=0x2905d7e4D048d29954F81b02171DD313F457a4a4 ) => ( 99489 )
              • UniswapV3Pool.swap( recipient=0x2905d7e4D048d29954F81b02171DD313F457a4a4, zeroForOne=False, amountSpecified=99488, sqrtPriceLimitX96=1461446703485210103287273052203988822378723970341, data=0x0000000000000000000000002260FAC5E5542A773AA44FBCFEDF7C193BC2C5990000000000000000000000000000000000000000000000000000000000000000 ) => ( amount0=-100500, amount1=99488 )
              • TransparentUpgradeableProxy.70a08231( )
              • TransparentUpgradeableProxy.a9059cbb( )
              • TransparentUpgradeableProxy.70a08231( )
                • uniBTC.balanceOf( account=0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE ) => ( 100500 )
                • TransparentUpgradeableProxy.70a08231( )
                  • uniBTC.balanceOf( account=0x1231DEB6f5749EF6cE6943a275A1D3E7486F4EaE ) => ( 100500 )
                  • TransparentUpgradeableProxy.a9059cbb( )
                    • uniBTC.transfer( to=0x1a39594D1657cCec689D7d84D8DE8F7652A7a036, amount=100500 ) => ( True )
                      File 1 of 9: WETH9
                      // Copyright (C) 2015, 2016, 2017 Dapphub
                      
                      // This program is free software: you can redistribute it and/or modify
                      // it under the terms of the GNU General Public License as published by
                      // the Free Software Foundation, either version 3 of the License, or
                      // (at your option) any later version.
                      
                      // This program is distributed in the hope that it will be useful,
                      // but WITHOUT ANY WARRANTY; without even the implied warranty of
                      // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                      // GNU General Public License for more details.
                      
                      // You should have received a copy of the GNU General Public License
                      // along with this program.  If not, see <http://www.gnu.org/licenses/>.
                      
                      pragma solidity ^0.4.18;
                      
                      contract WETH9 {
                          string public name     = "Wrapped Ether";
                          string public symbol   = "WETH";
                          uint8  public decimals = 18;
                      
                          event  Approval(address indexed src, address indexed guy, uint wad);
                          event  Transfer(address indexed src, address indexed dst, uint wad);
                          event  Deposit(address indexed dst, uint wad);
                          event  Withdrawal(address indexed src, uint wad);
                      
                          mapping (address => uint)                       public  balanceOf;
                          mapping (address => mapping (address => uint))  public  allowance;
                      
                          function() public payable {
                              deposit();
                          }
                          function deposit() public payable {
                              balanceOf[msg.sender] += msg.value;
                              Deposit(msg.sender, msg.value);
                          }
                          function withdraw(uint wad) public {
                              require(balanceOf[msg.sender] >= wad);
                              balanceOf[msg.sender] -= wad;
                              msg.sender.transfer(wad);
                              Withdrawal(msg.sender, wad);
                          }
                      
                          function totalSupply() public view returns (uint) {
                              return this.balance;
                          }
                      
                          function approve(address guy, uint wad) public returns (bool) {
                              allowance[msg.sender][guy] = wad;
                              Approval(msg.sender, guy, wad);
                              return true;
                          }
                      
                          function transfer(address dst, uint wad) public returns (bool) {
                              return transferFrom(msg.sender, dst, wad);
                          }
                      
                          function transferFrom(address src, address dst, uint wad)
                              public
                              returns (bool)
                          {
                              require(balanceOf[src] >= wad);
                      
                              if (src != msg.sender && allowance[src][msg.sender] != uint(-1)) {
                                  require(allowance[src][msg.sender] >= wad);
                                  allowance[src][msg.sender] -= wad;
                              }
                      
                              balanceOf[src] -= wad;
                              balanceOf[dst] += wad;
                      
                              Transfer(src, dst, wad);
                      
                              return true;
                          }
                      }
                      
                      
                      /*
                                          GNU GENERAL PUBLIC LICENSE
                                             Version 3, 29 June 2007
                      
                       Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
                       Everyone is permitted to copy and distribute verbatim copies
                       of this license document, but changing it is not allowed.
                      
                                                  Preamble
                      
                        The GNU General Public License is a free, copyleft license for
                      software and other kinds of works.
                      
                        The licenses for most software and other practical works are designed
                      to take away your freedom to share and change the works.  By contrast,
                      the GNU General Public License is intended to guarantee your freedom to
                      share and change all versions of a program--to make sure it remains free
                      software for all its users.  We, the Free Software Foundation, use the
                      GNU General Public License for most of our software; it applies also to
                      any other work released this way by its authors.  You can apply it to
                      your programs, too.
                      
                        When we speak of free software, we are referring to freedom, not
                      price.  Our General Public Licenses are designed to make sure that you
                      have the freedom to distribute copies of free software (and charge for
                      them if you wish), that you receive source code or can get it if you
                      want it, that you can change the software or use pieces of it in new
                      free programs, and that you know you can do these things.
                      
                        To protect your rights, we need to prevent others from denying you
                      these rights or asking you to surrender the rights.  Therefore, you have
                      certain responsibilities if you distribute copies of the software, or if
                      you modify it: responsibilities to respect the freedom of others.
                      
                        For example, if you distribute copies of such a program, whether
                      gratis or for a fee, you must pass on to the recipients the same
                      freedoms that you received.  You must make sure that they, too, receive
                      or can get the source code.  And you must show them these terms so they
                      know their rights.
                      
                        Developers that use the GNU GPL protect your rights with two steps:
                      (1) assert copyright on the software, and (2) offer you this License
                      giving you legal permission to copy, distribute and/or modify it.
                      
                        For the developers' and authors' protection, the GPL clearly explains
                      that there is no warranty for this free software.  For both users' and
                      authors' sake, the GPL requires that modified versions be marked as
                      changed, so that their problems will not be attributed erroneously to
                      authors of previous versions.
                      
                        Some devices are designed to deny users access to install or run
                      modified versions of the software inside them, although the manufacturer
                      can do so.  This is fundamentally incompatible with the aim of
                      protecting users' freedom to change the software.  The systematic
                      pattern of such abuse occurs in the area of products for individuals to
                      use, which is precisely where it is most unacceptable.  Therefore, we
                      have designed this version of the GPL to prohibit the practice for those
                      products.  If such problems arise substantially in other domains, we
                      stand ready to extend this provision to those domains in future versions
                      of the GPL, as needed to protect the freedom of users.
                      
                        Finally, every program is threatened constantly by software patents.
                      States should not allow patents to restrict development and use of
                      software on general-purpose computers, but in those that do, we wish to
                      avoid the special danger that patents applied to a free program could
                      make it effectively proprietary.  To prevent this, the GPL assures that
                      patents cannot be used to render the program non-free.
                      
                        The precise terms and conditions for copying, distribution and
                      modification follow.
                      
                                             TERMS AND CONDITIONS
                      
                        0. Definitions.
                      
                        "This License" refers to version 3 of the GNU General Public License.
                      
                        "Copyright" also means copyright-like laws that apply to other kinds of
                      works, such as semiconductor masks.
                      
                        "The Program" refers to any copyrightable work licensed under this
                      License.  Each licensee is addressed as "you".  "Licensees" and
                      "recipients" may be individuals or organizations.
                      
                        To "modify" a work means to copy from or adapt all or part of the work
                      in a fashion requiring copyright permission, other than the making of an
                      exact copy.  The resulting work is called a "modified version" of the
                      earlier work or a work "based on" the earlier work.
                      
                        A "covered work" means either the unmodified Program or a work based
                      on the Program.
                      
                        To "propagate" a work means to do anything with it that, without
                      permission, would make you directly or secondarily liable for
                      infringement under applicable copyright law, except executing it on a
                      computer or modifying a private copy.  Propagation includes copying,
                      distribution (with or without modification), making available to the
                      public, and in some countries other activities as well.
                      
                        To "convey" a work means any kind of propagation that enables other
                      parties to make or receive copies.  Mere interaction with a user through
                      a computer network, with no transfer of a copy, is not conveying.
                      
                        An interactive user interface displays "Appropriate Legal Notices"
                      to the extent that it includes a convenient and prominently visible
                      feature that (1) displays an appropriate copyright notice, and (2)
                      tells the user that there is no warranty for the work (except to the
                      extent that warranties are provided), that licensees may convey the
                      work under this License, and how to view a copy of this License.  If
                      the interface presents a list of user commands or options, such as a
                      menu, a prominent item in the list meets this criterion.
                      
                        1. Source Code.
                      
                        The "source code" for a work means the preferred form of the work
                      for making modifications to it.  "Object code" means any non-source
                      form of a work.
                      
                        A "Standard Interface" means an interface that either is an official
                      standard defined by a recognized standards body, or, in the case of
                      interfaces specified for a particular programming language, one that
                      is widely used among developers working in that language.
                      
                        The "System Libraries" of an executable work include anything, other
                      than the work as a whole, that (a) is included in the normal form of
                      packaging a Major Component, but which is not part of that Major
                      Component, and (b) serves only to enable use of the work with that
                      Major Component, or to implement a Standard Interface for which an
                      implementation is available to the public in source code form.  A
                      "Major Component", in this context, means a major essential component
                      (kernel, window system, and so on) of the specific operating system
                      (if any) on which the executable work runs, or a compiler used to
                      produce the work, or an object code interpreter used to run it.
                      
                        The "Corresponding Source" for a work in object code form means all
                      the source code needed to generate, install, and (for an executable
                      work) run the object code and to modify the work, including scripts to
                      control those activities.  However, it does not include the work's
                      System Libraries, or general-purpose tools or generally available free
                      programs which are used unmodified in performing those activities but
                      which are not part of the work.  For example, Corresponding Source
                      includes interface definition files associated with source files for
                      the work, and the source code for shared libraries and dynamically
                      linked subprograms that the work is specifically designed to require,
                      such as by intimate data communication or control flow between those
                      subprograms and other parts of the work.
                      
                        The Corresponding Source need not include anything that users
                      can regenerate automatically from other parts of the Corresponding
                      Source.
                      
                        The Corresponding Source for a work in source code form is that
                      same work.
                      
                        2. Basic Permissions.
                      
                        All rights granted under this License are granted for the term of
                      copyright on the Program, and are irrevocable provided the stated
                      conditions are met.  This License explicitly affirms your unlimited
                      permission to run the unmodified Program.  The output from running a
                      covered work is covered by this License only if the output, given its
                      content, constitutes a covered work.  This License acknowledges your
                      rights of fair use or other equivalent, as provided by copyright law.
                      
                        You may make, run and propagate covered works that you do not
                      convey, without conditions so long as your license otherwise remains
                      in force.  You may convey covered works to others for the sole purpose
                      of having them make modifications exclusively for you, or provide you
                      with facilities for running those works, provided that you comply with
                      the terms of this License in conveying all material for which you do
                      not control copyright.  Those thus making or running the covered works
                      for you must do so exclusively on your behalf, under your direction
                      and control, on terms that prohibit them from making any copies of
                      your copyrighted material outside their relationship with you.
                      
                        Conveying under any other circumstances is permitted solely under
                      the conditions stated below.  Sublicensing is not allowed; section 10
                      makes it unnecessary.
                      
                        3. Protecting Users' Legal Rights From Anti-Circumvention Law.
                      
                        No covered work shall be deemed part of an effective technological
                      measure under any applicable law fulfilling obligations under article
                      11 of the WIPO copyright treaty adopted on 20 December 1996, or
                      similar laws prohibiting or restricting circumvention of such
                      measures.
                      
                        When you convey a covered work, you waive any legal power to forbid
                      circumvention of technological measures to the extent such circumvention
                      is effected by exercising rights under this License with respect to
                      the covered work, and you disclaim any intention to limit operation or
                      modification of the work as a means of enforcing, against the work's
                      users, your or third parties' legal rights to forbid circumvention of
                      technological measures.
                      
                        4. Conveying Verbatim Copies.
                      
                        You may convey verbatim copies of the Program's source code as you
                      receive it, in any medium, provided that you conspicuously and
                      appropriately publish on each copy an appropriate copyright notice;
                      keep intact all notices stating that this License and any
                      non-permissive terms added in accord with section 7 apply to the code;
                      keep intact all notices of the absence of any warranty; and give all
                      recipients a copy of this License along with the Program.
                      
                        You may charge any price or no price for each copy that you convey,
                      and you may offer support or warranty protection for a fee.
                      
                        5. Conveying Modified Source Versions.
                      
                        You may convey a work based on the Program, or the modifications to
                      produce it from the Program, in the form of source code under the
                      terms of section 4, provided that you also meet all of these conditions:
                      
                          a) The work must carry prominent notices stating that you modified
                          it, and giving a relevant date.
                      
                          b) The work must carry prominent notices stating that it is
                          released under this License and any conditions added under section
                          7.  This requirement modifies the requirement in section 4 to
                          "keep intact all notices".
                      
                          c) You must license the entire work, as a whole, under this
                          License to anyone who comes into possession of a copy.  This
                          License will therefore apply, along with any applicable section 7
                          additional terms, to the whole of the work, and all its parts,
                          regardless of how they are packaged.  This License gives no
                          permission to license the work in any other way, but it does not
                          invalidate such permission if you have separately received it.
                      
                          d) If the work has interactive user interfaces, each must display
                          Appropriate Legal Notices; however, if the Program has interactive
                          interfaces that do not display Appropriate Legal Notices, your
                          work need not make them do so.
                      
                        A compilation of a covered work with other separate and independent
                      works, which are not by their nature extensions of the covered work,
                      and which are not combined with it such as to form a larger program,
                      in or on a volume of a storage or distribution medium, is called an
                      "aggregate" if the compilation and its resulting copyright are not
                      used to limit the access or legal rights of the compilation's users
                      beyond what the individual works permit.  Inclusion of a covered work
                      in an aggregate does not cause this License to apply to the other
                      parts of the aggregate.
                      
                        6. Conveying Non-Source Forms.
                      
                        You may convey a covered work in object code form under the terms
                      of sections 4 and 5, provided that you also convey the
                      machine-readable Corresponding Source under the terms of this License,
                      in one of these ways:
                      
                          a) Convey the object code in, or embodied in, a physical product
                          (including a physical distribution medium), accompanied by the
                          Corresponding Source fixed on a durable physical medium
                          customarily used for software interchange.
                      
                          b) Convey the object code in, or embodied in, a physical product
                          (including a physical distribution medium), accompanied by a
                          written offer, valid for at least three years and valid for as
                          long as you offer spare parts or customer support for that product
                          model, to give anyone who possesses the object code either (1) a
                          copy of the Corresponding Source for all the software in the
                          product that is covered by this License, on a durable physical
                          medium customarily used for software interchange, for a price no
                          more than your reasonable cost of physically performing this
                          conveying of source, or (2) access to copy the
                          Corresponding Source from a network server at no charge.
                      
                          c) Convey individual copies of the object code with a copy of the
                          written offer to provide the Corresponding Source.  This
                          alternative is allowed only occasionally and noncommercially, and
                          only if you received the object code with such an offer, in accord
                          with subsection 6b.
                      
                          d) Convey the object code by offering access from a designated
                          place (gratis or for a charge), and offer equivalent access to the
                          Corresponding Source in the same way through the same place at no
                          further charge.  You need not require recipients to copy the
                          Corresponding Source along with the object code.  If the place to
                          copy the object code is a network server, the Corresponding Source
                          may be on a different server (operated by you or a third party)
                          that supports equivalent copying facilities, provided you maintain
                          clear directions next to the object code saying where to find the
                          Corresponding Source.  Regardless of what server hosts the
                          Corresponding Source, you remain obligated to ensure that it is
                          available for as long as needed to satisfy these requirements.
                      
                          e) Convey the object code using peer-to-peer transmission, provided
                          you inform other peers where the object code and Corresponding
                          Source of the work are being offered to the general public at no
                          charge under subsection 6d.
                      
                        A separable portion of the object code, whose source code is excluded
                      from the Corresponding Source as a System Library, need not be
                      included in conveying the object code work.
                      
                        A "User Product" is either (1) a "consumer product", which means any
                      tangible personal property which is normally used for personal, family,
                      or household purposes, or (2) anything designed or sold for incorporation
                      into a dwelling.  In determining whether a product is a consumer product,
                      doubtful cases shall be resolved in favor of coverage.  For a particular
                      product received by a particular user, "normally used" refers to a
                      typical or common use of that class of product, regardless of the status
                      of the particular user or of the way in which the particular user
                      actually uses, or expects or is expected to use, the product.  A product
                      is a consumer product regardless of whether the product has substantial
                      commercial, industrial or non-consumer uses, unless such uses represent
                      the only significant mode of use of the product.
                      
                        "Installation Information" for a User Product means any methods,
                      procedures, authorization keys, or other information required to install
                      and execute modified versions of a covered work in that User Product from
                      a modified version of its Corresponding Source.  The information must
                      suffice to ensure that the continued functioning of the modified object
                      code is in no case prevented or interfered with solely because
                      modification has been made.
                      
                        If you convey an object code work under this section in, or with, or
                      specifically for use in, a User Product, and the conveying occurs as
                      part of a transaction in which the right of possession and use of the
                      User Product is transferred to the recipient in perpetuity or for a
                      fixed term (regardless of how the transaction is characterized), the
                      Corresponding Source conveyed under this section must be accompanied
                      by the Installation Information.  But this requirement does not apply
                      if neither you nor any third party retains the ability to install
                      modified object code on the User Product (for example, the work has
                      been installed in ROM).
                      
                        The requirement to provide Installation Information does not include a
                      requirement to continue to provide support service, warranty, or updates
                      for a work that has been modified or installed by the recipient, or for
                      the User Product in which it has been modified or installed.  Access to a
                      network may be denied when the modification itself materially and
                      adversely affects the operation of the network or violates the rules and
                      protocols for communication across the network.
                      
                        Corresponding Source conveyed, and Installation Information provided,
                      in accord with this section must be in a format that is publicly
                      documented (and with an implementation available to the public in
                      source code form), and must require no special password or key for
                      unpacking, reading or copying.
                      
                        7. Additional Terms.
                      
                        "Additional permissions" are terms that supplement the terms of this
                      License by making exceptions from one or more of its conditions.
                      Additional permissions that are applicable to the entire Program shall
                      be treated as though they were included in this License, to the extent
                      that they are valid under applicable law.  If additional permissions
                      apply only to part of the Program, that part may be used separately
                      under those permissions, but the entire Program remains governed by
                      this License without regard to the additional permissions.
                      
                        When you convey a copy of a covered work, you may at your option
                      remove any additional permissions from that copy, or from any part of
                      it.  (Additional permissions may be written to require their own
                      removal in certain cases when you modify the work.)  You may place
                      additional permissions on material, added by you to a covered work,
                      for which you have or can give appropriate copyright permission.
                      
                        Notwithstanding any other provision of this License, for material you
                      add to a covered work, you may (if authorized by the copyright holders of
                      that material) supplement the terms of this License with terms:
                      
                          a) Disclaiming warranty or limiting liability differently from the
                          terms of sections 15 and 16 of this License; or
                      
                          b) Requiring preservation of specified reasonable legal notices or
                          author attributions in that material or in the Appropriate Legal
                          Notices displayed by works containing it; or
                      
                          c) Prohibiting misrepresentation of the origin of that material, or
                          requiring that modified versions of such material be marked in
                          reasonable ways as different from the original version; or
                      
                          d) Limiting the use for publicity purposes of names of licensors or
                          authors of the material; or
                      
                          e) Declining to grant rights under trademark law for use of some
                          trade names, trademarks, or service marks; or
                      
                          f) Requiring indemnification of licensors and authors of that
                          material by anyone who conveys the material (or modified versions of
                          it) with contractual assumptions of liability to the recipient, for
                          any liability that these contractual assumptions directly impose on
                          those licensors and authors.
                      
                        All other non-permissive additional terms are considered "further
                      restrictions" within the meaning of section 10.  If the Program as you
                      received it, or any part of it, contains a notice stating that it is
                      governed by this License along with a term that is a further
                      restriction, you may remove that term.  If a license document contains
                      a further restriction but permits relicensing or conveying under this
                      License, you may add to a covered work material governed by the terms
                      of that license document, provided that the further restriction does
                      not survive such relicensing or conveying.
                      
                        If you add terms to a covered work in accord with this section, you
                      must place, in the relevant source files, a statement of the
                      additional terms that apply to those files, or a notice indicating
                      where to find the applicable terms.
                      
                        Additional terms, permissive or non-permissive, may be stated in the
                      form of a separately written license, or stated as exceptions;
                      the above requirements apply either way.
                      
                        8. Termination.
                      
                        You may not propagate or modify a covered work except as expressly
                      provided under this License.  Any attempt otherwise to propagate or
                      modify it is void, and will automatically terminate your rights under
                      this License (including any patent licenses granted under the third
                      paragraph of section 11).
                      
                        However, if you cease all violation of this License, then your
                      license from a particular copyright holder is reinstated (a)
                      provisionally, unless and until the copyright holder explicitly and
                      finally terminates your license, and (b) permanently, if the copyright
                      holder fails to notify you of the violation by some reasonable means
                      prior to 60 days after the cessation.
                      
                        Moreover, your license from a particular copyright holder is
                      reinstated permanently if the copyright holder notifies you of the
                      violation by some reasonable means, this is the first time you have
                      received notice of violation of this License (for any work) from that
                      copyright holder, and you cure the violation prior to 30 days after
                      your receipt of the notice.
                      
                        Termination of your rights under this section does not terminate the
                      licenses of parties who have received copies or rights from you under
                      this License.  If your rights have been terminated and not permanently
                      reinstated, you do not qualify to receive new licenses for the same
                      material under section 10.
                      
                        9. Acceptance Not Required for Having Copies.
                      
                        You are not required to accept this License in order to receive or
                      run a copy of the Program.  Ancillary propagation of a covered work
                      occurring solely as a consequence of using peer-to-peer transmission
                      to receive a copy likewise does not require acceptance.  However,
                      nothing other than this License grants you permission to propagate or
                      modify any covered work.  These actions infringe copyright if you do
                      not accept this License.  Therefore, by modifying or propagating a
                      covered work, you indicate your acceptance of this License to do so.
                      
                        10. Automatic Licensing of Downstream Recipients.
                      
                        Each time you convey a covered work, the recipient automatically
                      receives a license from the original licensors, to run, modify and
                      propagate that work, subject to this License.  You are not responsible
                      for enforcing compliance by third parties with this License.
                      
                        An "entity transaction" is a transaction transferring control of an
                      organization, or substantially all assets of one, or subdividing an
                      organization, or merging organizations.  If propagation of a covered
                      work results from an entity transaction, each party to that
                      transaction who receives a copy of the work also receives whatever
                      licenses to the work the party's predecessor in interest had or could
                      give under the previous paragraph, plus a right to possession of the
                      Corresponding Source of the work from the predecessor in interest, if
                      the predecessor has it or can get it with reasonable efforts.
                      
                        You may not impose any further restrictions on the exercise of the
                      rights granted or affirmed under this License.  For example, you may
                      not impose a license fee, royalty, or other charge for exercise of
                      rights granted under this License, and you may not initiate litigation
                      (including a cross-claim or counterclaim in a lawsuit) alleging that
                      any patent claim is infringed by making, using, selling, offering for
                      sale, or importing the Program or any portion of it.
                      
                        11. Patents.
                      
                        A "contributor" is a copyright holder who authorizes use under this
                      License of the Program or a work on which the Program is based.  The
                      work thus licensed is called the contributor's "contributor version".
                      
                        A contributor's "essential patent claims" are all patent claims
                      owned or controlled by the contributor, whether already acquired or
                      hereafter acquired, that would be infringed by some manner, permitted
                      by this License, of making, using, or selling its contributor version,
                      but do not include claims that would be infringed only as a
                      consequence of further modification of the contributor version.  For
                      purposes of this definition, "control" includes the right to grant
                      patent sublicenses in a manner consistent with the requirements of
                      this License.
                      
                        Each contributor grants you a non-exclusive, worldwide, royalty-free
                      patent license under the contributor's essential patent claims, to
                      make, use, sell, offer for sale, import and otherwise run, modify and
                      propagate the contents of its contributor version.
                      
                        In the following three paragraphs, a "patent license" is any express
                      agreement or commitment, however denominated, not to enforce a patent
                      (such as an express permission to practice a patent or covenant not to
                      sue for patent infringement).  To "grant" such a patent license to a
                      party means to make such an agreement or commitment not to enforce a
                      patent against the party.
                      
                        If you convey a covered work, knowingly relying on a patent license,
                      and the Corresponding Source of the work is not available for anyone
                      to copy, free of charge and under the terms of this License, through a
                      publicly available network server or other readily accessible means,
                      then you must either (1) cause the Corresponding Source to be so
                      available, or (2) arrange to deprive yourself of the benefit of the
                      patent license for this particular work, or (3) arrange, in a manner
                      consistent with the requirements of this License, to extend the patent
                      license to downstream recipients.  "Knowingly relying" means you have
                      actual knowledge that, but for the patent license, your conveying the
                      covered work in a country, or your recipient's use of the covered work
                      in a country, would infringe one or more identifiable patents in that
                      country that you have reason to believe are valid.
                      
                        If, pursuant to or in connection with a single transaction or
                      arrangement, you convey, or propagate by procuring conveyance of, a
                      covered work, and grant a patent license to some of the parties
                      receiving the covered work authorizing them to use, propagate, modify
                      or convey a specific copy of the covered work, then the patent license
                      you grant is automatically extended to all recipients of the covered
                      work and works based on it.
                      
                        A patent license is "discriminatory" if it does not include within
                      the scope of its coverage, prohibits the exercise of, or is
                      conditioned on the non-exercise of one or more of the rights that are
                      specifically granted under this License.  You may not convey a covered
                      work if you are a party to an arrangement with a third party that is
                      in the business of distributing software, under which you make payment
                      to the third party based on the extent of your activity of conveying
                      the work, and under which the third party grants, to any of the
                      parties who would receive the covered work from you, a discriminatory
                      patent license (a) in connection with copies of the covered work
                      conveyed by you (or copies made from those copies), or (b) primarily
                      for and in connection with specific products or compilations that
                      contain the covered work, unless you entered into that arrangement,
                      or that patent license was granted, prior to 28 March 2007.
                      
                        Nothing in this License shall be construed as excluding or limiting
                      any implied license or other defenses to infringement that may
                      otherwise be available to you under applicable patent law.
                      
                        12. No Surrender of Others' Freedom.
                      
                        If conditions are imposed on you (whether by court order, agreement or
                      otherwise) that contradict the conditions of this License, they do not
                      excuse you from the conditions of this License.  If you cannot convey a
                      covered work so as to satisfy simultaneously your obligations under this
                      License and any other pertinent obligations, then as a consequence you may
                      not convey it at all.  For example, if you agree to terms that obligate you
                      to collect a royalty for further conveying from those to whom you convey
                      the Program, the only way you could satisfy both those terms and this
                      License would be to refrain entirely from conveying the Program.
                      
                        13. Use with the GNU Affero General Public License.
                      
                        Notwithstanding any other provision of this License, you have
                      permission to link or combine any covered work with a work licensed
                      under version 3 of the GNU Affero General Public License into a single
                      combined work, and to convey the resulting work.  The terms of this
                      License will continue to apply to the part which is the covered work,
                      but the special requirements of the GNU Affero General Public License,
                      section 13, concerning interaction through a network will apply to the
                      combination as such.
                      
                        14. Revised Versions of this License.
                      
                        The Free Software Foundation may publish revised and/or new versions of
                      the GNU General Public License from time to time.  Such new versions will
                      be similar in spirit to the present version, but may differ in detail to
                      address new problems or concerns.
                      
                        Each version is given a distinguishing version number.  If the
                      Program specifies that a certain numbered version of the GNU General
                      Public License "or any later version" applies to it, you have the
                      option of following the terms and conditions either of that numbered
                      version or of any later version published by the Free Software
                      Foundation.  If the Program does not specify a version number of the
                      GNU General Public License, you may choose any version ever published
                      by the Free Software Foundation.
                      
                        If the Program specifies that a proxy can decide which future
                      versions of the GNU General Public License can be used, that proxy's
                      public statement of acceptance of a version permanently authorizes you
                      to choose that version for the Program.
                      
                        Later license versions may give you additional or different
                      permissions.  However, no additional obligations are imposed on any
                      author or copyright holder as a result of your choosing to follow a
                      later version.
                      
                        15. Disclaimer of Warranty.
                      
                        THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
                      APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
                      HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
                      OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
                      THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
                      PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
                      IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
                      ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
                      
                        16. Limitation of Liability.
                      
                        IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
                      WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
                      THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
                      GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
                      USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
                      DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
                      PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
                      EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
                      SUCH DAMAGES.
                      
                        17. Interpretation of Sections 15 and 16.
                      
                        If the disclaimer of warranty and limitation of liability provided
                      above cannot be given local legal effect according to their terms,
                      reviewing courts shall apply local law that most closely approximates
                      an absolute waiver of all civil liability in connection with the
                      Program, unless a warranty or assumption of liability accompanies a
                      copy of the Program in return for a fee.
                      
                                           END OF TERMS AND CONDITIONS
                      
                                  How to Apply These Terms to Your New Programs
                      
                        If you develop a new program, and you want it to be of the greatest
                      possible use to the public, the best way to achieve this is to make it
                      free software which everyone can redistribute and change under these terms.
                      
                        To do so, attach the following notices to the program.  It is safest
                      to attach them to the start of each source file to most effectively
                      state the exclusion of warranty; and each file should have at least
                      the "copyright" line and a pointer to where the full notice is found.
                      
                          <one line to give the program's name and a brief idea of what it does.>
                          Copyright (C) <year>  <name of author>
                      
                          This program is free software: you can redistribute it and/or modify
                          it under the terms of the GNU General Public License as published by
                          the Free Software Foundation, either version 3 of the License, or
                          (at your option) any later version.
                      
                          This program is distributed in the hope that it will be useful,
                          but WITHOUT ANY WARRANTY; without even the implied warranty of
                          MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                          GNU General Public License for more details.
                      
                          You should have received a copy of the GNU General Public License
                          along with this program.  If not, see <http://www.gnu.org/licenses/>.
                      
                      Also add information on how to contact you by electronic and paper mail.
                      
                        If the program does terminal interaction, make it output a short
                      notice like this when it starts in an interactive mode:
                      
                          <program>  Copyright (C) <year>  <name of author>
                          This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
                          This is free software, and you are welcome to redistribute it
                          under certain conditions; type `show c' for details.
                      
                      The hypothetical commands `show w' and `show c' should show the appropriate
                      parts of the General Public License.  Of course, your program's commands
                      might be different; for a GUI interface, you would use an "about box".
                      
                        You should also get your employer (if you work as a programmer) or school,
                      if any, to sign a "copyright disclaimer" for the program, if necessary.
                      For more information on this, and how to apply and follow the GNU GPL, see
                      <http://www.gnu.org/licenses/>.
                      
                        The GNU General Public License does not permit incorporating your program
                      into proprietary programs.  If your program is a subroutine library, you
                      may consider it more useful to permit linking proprietary applications with
                      the library.  If this is what you want to do, use the GNU Lesser General
                      Public License instead of this License.  But first, please read
                      <http://www.gnu.org/philosophy/why-not-lgpl.html>.
                      
                      */

                      File 2 of 9: UniswapV2Pair
                      // File: contracts/uniswapv2/interfaces/IUniswapV2Factory.sol
                      
                      pragma solidity >=0.5.0;
                      
                      interface IUniswapV2Factory {
                          event PairCreated(address indexed token0, address indexed token1, address pair, uint);
                      
                          function feeTo() external view returns (address);
                          function feeToSetter() external view returns (address);
                          function migrator() external view returns (address);
                      
                          function getPair(address tokenA, address tokenB) external view returns (address pair);
                          function allPairs(uint) external view returns (address pair);
                          function allPairsLength() external view returns (uint);
                      
                          function createPair(address tokenA, address tokenB) external returns (address pair);
                      
                          function setFeeTo(address) external;
                          function setFeeToSetter(address) external;
                          function setMigrator(address) external;
                      }
                      
                      // File: contracts/uniswapv2/libraries/SafeMath.sol
                      
                      pragma solidity =0.6.12;
                      
                      // a library for performing overflow-safe math, courtesy of DappHub (https://github.com/dapphub/ds-math)
                      
                      library SafeMathUniswap {
                          function add(uint x, uint y) internal pure returns (uint z) {
                              require((z = x + y) >= x, 'ds-math-add-overflow');
                          }
                      
                          function sub(uint x, uint y) internal pure returns (uint z) {
                              require((z = x - y) <= x, 'ds-math-sub-underflow');
                          }
                      
                          function mul(uint x, uint y) internal pure returns (uint z) {
                              require(y == 0 || (z = x * y) / y == x, 'ds-math-mul-overflow');
                          }
                      }
                      
                      // File: contracts/uniswapv2/UniswapV2ERC20.sol
                      
                      pragma solidity =0.6.12;
                      
                      
                      contract UniswapV2ERC20 {
                          using SafeMathUniswap for uint;
                      
                          string public constant name = 'SushiSwap LP Token';
                          string public constant symbol = 'SLP';
                          uint8 public constant decimals = 18;
                          uint  public totalSupply;
                          mapping(address => uint) public balanceOf;
                          mapping(address => mapping(address => uint)) public allowance;
                      
                          bytes32 public DOMAIN_SEPARATOR;
                          // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
                          bytes32 public constant PERMIT_TYPEHASH = 0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
                          mapping(address => uint) public nonces;
                      
                          event Approval(address indexed owner, address indexed spender, uint value);
                          event Transfer(address indexed from, address indexed to, uint value);
                      
                          constructor() public {
                              uint chainId;
                              assembly {
                                  chainId := chainid()
                              }
                              DOMAIN_SEPARATOR = keccak256(
                                  abi.encode(
                                      keccak256('EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)'),
                                      keccak256(bytes(name)),
                                      keccak256(bytes('1')),
                                      chainId,
                                      address(this)
                                  )
                              );
                          }
                      
                          function _mint(address to, uint value) internal {
                              totalSupply = totalSupply.add(value);
                              balanceOf[to] = balanceOf[to].add(value);
                              emit Transfer(address(0), to, value);
                          }
                      
                          function _burn(address from, uint value) internal {
                              balanceOf[from] = balanceOf[from].sub(value);
                              totalSupply = totalSupply.sub(value);
                              emit Transfer(from, address(0), value);
                          }
                      
                          function _approve(address owner, address spender, uint value) private {
                              allowance[owner][spender] = value;
                              emit Approval(owner, spender, value);
                          }
                      
                          function _transfer(address from, address to, uint value) private {
                              balanceOf[from] = balanceOf[from].sub(value);
                              balanceOf[to] = balanceOf[to].add(value);
                              emit Transfer(from, to, value);
                          }
                      
                          function approve(address spender, uint value) external returns (bool) {
                              _approve(msg.sender, spender, value);
                              return true;
                          }
                      
                          function transfer(address to, uint value) external returns (bool) {
                              _transfer(msg.sender, to, value);
                              return true;
                          }
                      
                          function transferFrom(address from, address to, uint value) external returns (bool) {
                              if (allowance[from][msg.sender] != uint(-1)) {
                                  allowance[from][msg.sender] = allowance[from][msg.sender].sub(value);
                              }
                              _transfer(from, to, value);
                              return true;
                          }
                      
                          function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external {
                              require(deadline >= block.timestamp, 'UniswapV2: EXPIRED');
                              bytes32 digest = keccak256(
                                  abi.encodePacked(
                                      '\x19\x01',
                                      DOMAIN_SEPARATOR,
                                      keccak256(abi.encode(PERMIT_TYPEHASH, owner, spender, value, nonces[owner]++, deadline))
                                  )
                              );
                              address recoveredAddress = ecrecover(digest, v, r, s);
                              require(recoveredAddress != address(0) && recoveredAddress == owner, 'UniswapV2: INVALID_SIGNATURE');
                              _approve(owner, spender, value);
                          }
                      }
                      
                      // File: contracts/uniswapv2/libraries/Math.sol
                      
                      pragma solidity =0.6.12;
                      
                      // a library for performing various math operations
                      
                      library Math {
                          function min(uint x, uint y) internal pure returns (uint z) {
                              z = x < y ? x : y;
                          }
                      
                          // babylonian method (https://en.wikipedia.org/wiki/Methods_of_computing_square_roots#Babylonian_method)
                          function sqrt(uint y) internal pure returns (uint z) {
                              if (y > 3) {
                                  z = y;
                                  uint x = y / 2 + 1;
                                  while (x < z) {
                                      z = x;
                                      x = (y / x + x) / 2;
                                  }
                              } else if (y != 0) {
                                  z = 1;
                              }
                          }
                      }
                      
                      // File: contracts/uniswapv2/libraries/UQ112x112.sol
                      
                      pragma solidity =0.6.12;
                      
                      // a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
                      
                      // range: [0, 2**112 - 1]
                      // resolution: 1 / 2**112
                      
                      library UQ112x112 {
                          uint224 constant Q112 = 2**112;
                      
                          // encode a uint112 as a UQ112x112
                          function encode(uint112 y) internal pure returns (uint224 z) {
                              z = uint224(y) * Q112; // never overflows
                          }
                      
                          // divide a UQ112x112 by a uint112, returning a UQ112x112
                          function uqdiv(uint224 x, uint112 y) internal pure returns (uint224 z) {
                              z = x / uint224(y);
                          }
                      }
                      
                      // File: contracts/uniswapv2/interfaces/IERC20.sol
                      
                      pragma solidity >=0.5.0;
                      
                      interface IERC20Uniswap {
                          event Approval(address indexed owner, address indexed spender, uint value);
                          event Transfer(address indexed from, address indexed to, uint value);
                      
                          function name() external view returns (string memory);
                          function symbol() external view returns (string memory);
                          function decimals() external view returns (uint8);
                          function totalSupply() external view returns (uint);
                          function balanceOf(address owner) external view returns (uint);
                          function allowance(address owner, address spender) external view returns (uint);
                      
                          function approve(address spender, uint value) external returns (bool);
                          function transfer(address to, uint value) external returns (bool);
                          function transferFrom(address from, address to, uint value) external returns (bool);
                      }
                      
                      // File: contracts/uniswapv2/interfaces/IUniswapV2Callee.sol
                      
                      pragma solidity >=0.5.0;
                      
                      interface IUniswapV2Callee {
                          function uniswapV2Call(address sender, uint amount0, uint amount1, bytes calldata data) external;
                      }
                      
                      // File: contracts/uniswapv2/UniswapV2Pair.sol
                      
                      pragma solidity =0.6.12;
                      
                      
                      
                      
                      
                      
                      
                      
                      interface IMigrator {
                          // Return the desired amount of liquidity token that the migrator wants.
                          function desiredLiquidity() external view returns (uint256);
                      }
                      
                      contract UniswapV2Pair is UniswapV2ERC20 {
                          using SafeMathUniswap  for uint;
                          using UQ112x112 for uint224;
                      
                          uint public constant MINIMUM_LIQUIDITY = 10**3;
                          bytes4 private constant SELECTOR = bytes4(keccak256(bytes('transfer(address,uint256)')));
                      
                          address public factory;
                          address public token0;
                          address public token1;
                      
                          uint112 private reserve0;           // uses single storage slot, accessible via getReserves
                          uint112 private reserve1;           // uses single storage slot, accessible via getReserves
                          uint32  private blockTimestampLast; // uses single storage slot, accessible via getReserves
                      
                          uint public price0CumulativeLast;
                          uint public price1CumulativeLast;
                          uint public kLast; // reserve0 * reserve1, as of immediately after the most recent liquidity event
                      
                          uint private unlocked = 1;
                          modifier lock() {
                              require(unlocked == 1, 'UniswapV2: LOCKED');
                              unlocked = 0;
                              _;
                              unlocked = 1;
                          }
                      
                          function getReserves() public view returns (uint112 _reserve0, uint112 _reserve1, uint32 _blockTimestampLast) {
                              _reserve0 = reserve0;
                              _reserve1 = reserve1;
                              _blockTimestampLast = blockTimestampLast;
                          }
                      
                          function _safeTransfer(address token, address to, uint value) private {
                              (bool success, bytes memory data) = token.call(abi.encodeWithSelector(SELECTOR, to, value));
                              require(success && (data.length == 0 || abi.decode(data, (bool))), 'UniswapV2: TRANSFER_FAILED');
                          }
                      
                          event Mint(address indexed sender, uint amount0, uint amount1);
                          event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
                          event Swap(
                              address indexed sender,
                              uint amount0In,
                              uint amount1In,
                              uint amount0Out,
                              uint amount1Out,
                              address indexed to
                          );
                          event Sync(uint112 reserve0, uint112 reserve1);
                      
                          constructor() public {
                              factory = msg.sender;
                          }
                      
                          // called once by the factory at time of deployment
                          function initialize(address _token0, address _token1) external {
                              require(msg.sender == factory, 'UniswapV2: FORBIDDEN'); // sufficient check
                              token0 = _token0;
                              token1 = _token1;
                          }
                      
                          // update reserves and, on the first call per block, price accumulators
                          function _update(uint balance0, uint balance1, uint112 _reserve0, uint112 _reserve1) private {
                              require(balance0 <= uint112(-1) && balance1 <= uint112(-1), 'UniswapV2: OVERFLOW');
                              uint32 blockTimestamp = uint32(block.timestamp % 2**32);
                              uint32 timeElapsed = blockTimestamp - blockTimestampLast; // overflow is desired
                              if (timeElapsed > 0 && _reserve0 != 0 && _reserve1 != 0) {
                                  // * never overflows, and + overflow is desired
                                  price0CumulativeLast += uint(UQ112x112.encode(_reserve1).uqdiv(_reserve0)) * timeElapsed;
                                  price1CumulativeLast += uint(UQ112x112.encode(_reserve0).uqdiv(_reserve1)) * timeElapsed;
                              }
                              reserve0 = uint112(balance0);
                              reserve1 = uint112(balance1);
                              blockTimestampLast = blockTimestamp;
                              emit Sync(reserve0, reserve1);
                          }
                      
                          // if fee is on, mint liquidity equivalent to 1/6th of the growth in sqrt(k)
                          function _mintFee(uint112 _reserve0, uint112 _reserve1) private returns (bool feeOn) {
                              address feeTo = IUniswapV2Factory(factory).feeTo();
                              feeOn = feeTo != address(0);
                              uint _kLast = kLast; // gas savings
                              if (feeOn) {
                                  if (_kLast != 0) {
                                      uint rootK = Math.sqrt(uint(_reserve0).mul(_reserve1));
                                      uint rootKLast = Math.sqrt(_kLast);
                                      if (rootK > rootKLast) {
                                          uint numerator = totalSupply.mul(rootK.sub(rootKLast));
                                          uint denominator = rootK.mul(5).add(rootKLast);
                                          uint liquidity = numerator / denominator;
                                          if (liquidity > 0) _mint(feeTo, liquidity);
                                      }
                                  }
                              } else if (_kLast != 0) {
                                  kLast = 0;
                              }
                          }
                      
                          // this low-level function should be called from a contract which performs important safety checks
                          function mint(address to) external lock returns (uint liquidity) {
                              (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                              uint balance0 = IERC20Uniswap(token0).balanceOf(address(this));
                              uint balance1 = IERC20Uniswap(token1).balanceOf(address(this));
                              uint amount0 = balance0.sub(_reserve0);
                              uint amount1 = balance1.sub(_reserve1);
                      
                              bool feeOn = _mintFee(_reserve0, _reserve1);
                              uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
                              if (_totalSupply == 0) {
                                  address migrator = IUniswapV2Factory(factory).migrator();
                                  if (msg.sender == migrator) {
                                      liquidity = IMigrator(migrator).desiredLiquidity();
                                      require(liquidity > 0 && liquidity != uint256(-1), "Bad desired liquidity");
                                  } else {
                                      require(migrator == address(0), "Must not have migrator");
                                      liquidity = Math.sqrt(amount0.mul(amount1)).sub(MINIMUM_LIQUIDITY);
                                      _mint(address(0), MINIMUM_LIQUIDITY); // permanently lock the first MINIMUM_LIQUIDITY tokens
                                  }
                              } else {
                                  liquidity = Math.min(amount0.mul(_totalSupply) / _reserve0, amount1.mul(_totalSupply) / _reserve1);
                              }
                              require(liquidity > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_MINTED');
                              _mint(to, liquidity);
                      
                              _update(balance0, balance1, _reserve0, _reserve1);
                              if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
                              emit Mint(msg.sender, amount0, amount1);
                          }
                      
                          // this low-level function should be called from a contract which performs important safety checks
                          function burn(address to) external lock returns (uint amount0, uint amount1) {
                              (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                              address _token0 = token0;                                // gas savings
                              address _token1 = token1;                                // gas savings
                              uint balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
                              uint balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
                              uint liquidity = balanceOf[address(this)];
                      
                              bool feeOn = _mintFee(_reserve0, _reserve1);
                              uint _totalSupply = totalSupply; // gas savings, must be defined here since totalSupply can update in _mintFee
                              amount0 = liquidity.mul(balance0) / _totalSupply; // using balances ensures pro-rata distribution
                              amount1 = liquidity.mul(balance1) / _totalSupply; // using balances ensures pro-rata distribution
                              require(amount0 > 0 && amount1 > 0, 'UniswapV2: INSUFFICIENT_LIQUIDITY_BURNED');
                              _burn(address(this), liquidity);
                              _safeTransfer(_token0, to, amount0);
                              _safeTransfer(_token1, to, amount1);
                              balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
                              balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
                      
                              _update(balance0, balance1, _reserve0, _reserve1);
                              if (feeOn) kLast = uint(reserve0).mul(reserve1); // reserve0 and reserve1 are up-to-date
                              emit Burn(msg.sender, amount0, amount1, to);
                          }
                      
                          // this low-level function should be called from a contract which performs important safety checks
                          function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external lock {
                              require(amount0Out > 0 || amount1Out > 0, 'UniswapV2: INSUFFICIENT_OUTPUT_AMOUNT');
                              (uint112 _reserve0, uint112 _reserve1,) = getReserves(); // gas savings
                              require(amount0Out < _reserve0 && amount1Out < _reserve1, 'UniswapV2: INSUFFICIENT_LIQUIDITY');
                      
                              uint balance0;
                              uint balance1;
                              { // scope for _token{0,1}, avoids stack too deep errors
                              address _token0 = token0;
                              address _token1 = token1;
                              require(to != _token0 && to != _token1, 'UniswapV2: INVALID_TO');
                              if (amount0Out > 0) _safeTransfer(_token0, to, amount0Out); // optimistically transfer tokens
                              if (amount1Out > 0) _safeTransfer(_token1, to, amount1Out); // optimistically transfer tokens
                              if (data.length > 0) IUniswapV2Callee(to).uniswapV2Call(msg.sender, amount0Out, amount1Out, data);
                              balance0 = IERC20Uniswap(_token0).balanceOf(address(this));
                              balance1 = IERC20Uniswap(_token1).balanceOf(address(this));
                              }
                              uint amount0In = balance0 > _reserve0 - amount0Out ? balance0 - (_reserve0 - amount0Out) : 0;
                              uint amount1In = balance1 > _reserve1 - amount1Out ? balance1 - (_reserve1 - amount1Out) : 0;
                              require(amount0In > 0 || amount1In > 0, 'UniswapV2: INSUFFICIENT_INPUT_AMOUNT');
                              { // scope for reserve{0,1}Adjusted, avoids stack too deep errors
                              uint balance0Adjusted = balance0.mul(1000).sub(amount0In.mul(3));
                              uint balance1Adjusted = balance1.mul(1000).sub(amount1In.mul(3));
                              require(balance0Adjusted.mul(balance1Adjusted) >= uint(_reserve0).mul(_reserve1).mul(1000**2), 'UniswapV2: K');
                              }
                      
                              _update(balance0, balance1, _reserve0, _reserve1);
                              emit Swap(msg.sender, amount0In, amount1In, amount0Out, amount1Out, to);
                          }
                      
                          // force balances to match reserves
                          function skim(address to) external lock {
                              address _token0 = token0; // gas savings
                              address _token1 = token1; // gas savings
                              _safeTransfer(_token0, to, IERC20Uniswap(_token0).balanceOf(address(this)).sub(reserve0));
                              _safeTransfer(_token1, to, IERC20Uniswap(_token1).balanceOf(address(this)).sub(reserve1));
                          }
                      
                          // force reserves to match balances
                          function sync() external lock {
                              _update(IERC20Uniswap(token0).balanceOf(address(this)), IERC20Uniswap(token1).balanceOf(address(this)), reserve0, reserve1);
                          }
                      }

                      File 3 of 9: WBTC
                      pragma solidity 0.4.24;
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/ERC20Basic.sol
                      
                      /**
                       * @title ERC20Basic
                       * @dev Simpler version of ERC20 interface
                       * See https://github.com/ethereum/EIPs/issues/179
                       */
                      contract ERC20Basic {
                        function totalSupply() public view returns (uint256);
                        function balanceOf(address _who) public view returns (uint256);
                        function transfer(address _to, uint256 _value) public returns (bool);
                        event Transfer(address indexed from, address indexed to, uint256 value);
                      }
                      
                      // File: openzeppelin-solidity/contracts/math/SafeMath.sol
                      
                      /**
                       * @title SafeMath
                       * @dev Math operations with safety checks that throw on error
                       */
                      library SafeMath {
                      
                        /**
                        * @dev Multiplies two numbers, throws on overflow.
                        */
                        function mul(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
                          // Gas optimization: this is cheaper than asserting 'a' not being zero, but the
                          // benefit is lost if 'b' is also tested.
                          // See: https://github.com/OpenZeppelin/openzeppelin-solidity/pull/522
                          if (_a == 0) {
                            return 0;
                          }
                      
                          c = _a * _b;
                          assert(c / _a == _b);
                          return c;
                        }
                      
                        /**
                        * @dev Integer division of two numbers, truncating the quotient.
                        */
                        function div(uint256 _a, uint256 _b) internal pure returns (uint256) {
                          // assert(_b > 0); // Solidity automatically throws when dividing by 0
                          // uint256 c = _a / _b;
                          // assert(_a == _b * c + _a % _b); // There is no case in which this doesn't hold
                          return _a / _b;
                        }
                      
                        /**
                        * @dev Subtracts two numbers, throws on overflow (i.e. if subtrahend is greater than minuend).
                        */
                        function sub(uint256 _a, uint256 _b) internal pure returns (uint256) {
                          assert(_b <= _a);
                          return _a - _b;
                        }
                      
                        /**
                        * @dev Adds two numbers, throws on overflow.
                        */
                        function add(uint256 _a, uint256 _b) internal pure returns (uint256 c) {
                          c = _a + _b;
                          assert(c >= _a);
                          return c;
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/BasicToken.sol
                      
                      /**
                       * @title Basic token
                       * @dev Basic version of StandardToken, with no allowances.
                       */
                      contract BasicToken is ERC20Basic {
                        using SafeMath for uint256;
                      
                        mapping(address => uint256) internal balances;
                      
                        uint256 internal totalSupply_;
                      
                        /**
                        * @dev Total number of tokens in existence
                        */
                        function totalSupply() public view returns (uint256) {
                          return totalSupply_;
                        }
                      
                        /**
                        * @dev Transfer token for a specified address
                        * @param _to The address to transfer to.
                        * @param _value The amount to be transferred.
                        */
                        function transfer(address _to, uint256 _value) public returns (bool) {
                          require(_value <= balances[msg.sender]);
                          require(_to != address(0));
                      
                          balances[msg.sender] = balances[msg.sender].sub(_value);
                          balances[_to] = balances[_to].add(_value);
                          emit Transfer(msg.sender, _to, _value);
                          return true;
                        }
                      
                        /**
                        * @dev Gets the balance of the specified address.
                        * @param _owner The address to query the the balance of.
                        * @return An uint256 representing the amount owned by the passed address.
                        */
                        function balanceOf(address _owner) public view returns (uint256) {
                          return balances[_owner];
                        }
                      
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/ERC20.sol
                      
                      /**
                       * @title ERC20 interface
                       * @dev see https://github.com/ethereum/EIPs/issues/20
                       */
                      contract ERC20 is ERC20Basic {
                        function allowance(address _owner, address _spender)
                          public view returns (uint256);
                      
                        function transferFrom(address _from, address _to, uint256 _value)
                          public returns (bool);
                      
                        function approve(address _spender, uint256 _value) public returns (bool);
                        event Approval(
                          address indexed owner,
                          address indexed spender,
                          uint256 value
                        );
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/StandardToken.sol
                      
                      /**
                       * @title Standard ERC20 token
                       *
                       * @dev Implementation of the basic standard token.
                       * https://github.com/ethereum/EIPs/issues/20
                       * Based on code by FirstBlood: https://github.com/Firstbloodio/token/blob/master/smart_contract/FirstBloodToken.sol
                       */
                      contract StandardToken is ERC20, BasicToken {
                      
                        mapping (address => mapping (address => uint256)) internal allowed;
                      
                      
                        /**
                         * @dev Transfer tokens from one address to another
                         * @param _from address The address which you want to send tokens from
                         * @param _to address The address which you want to transfer to
                         * @param _value uint256 the amount of tokens to be transferred
                         */
                        function transferFrom(
                          address _from,
                          address _to,
                          uint256 _value
                        )
                          public
                          returns (bool)
                        {
                          require(_value <= balances[_from]);
                          require(_value <= allowed[_from][msg.sender]);
                          require(_to != address(0));
                      
                          balances[_from] = balances[_from].sub(_value);
                          balances[_to] = balances[_to].add(_value);
                          allowed[_from][msg.sender] = allowed[_from][msg.sender].sub(_value);
                          emit Transfer(_from, _to, _value);
                          return true;
                        }
                      
                        /**
                         * @dev Approve the passed address to spend the specified amount of tokens on behalf of msg.sender.
                         * Beware that changing an allowance with this method brings the risk that someone may use both the old
                         * and the new allowance by unfortunate transaction ordering. One possible solution to mitigate this
                         * race condition is to first reduce the spender's allowance to 0 and set the desired value afterwards:
                         * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                         * @param _spender The address which will spend the funds.
                         * @param _value The amount of tokens to be spent.
                         */
                        function approve(address _spender, uint256 _value) public returns (bool) {
                          allowed[msg.sender][_spender] = _value;
                          emit Approval(msg.sender, _spender, _value);
                          return true;
                        }
                      
                        /**
                         * @dev Function to check the amount of tokens that an owner allowed to a spender.
                         * @param _owner address The address which owns the funds.
                         * @param _spender address The address which will spend the funds.
                         * @return A uint256 specifying the amount of tokens still available for the spender.
                         */
                        function allowance(
                          address _owner,
                          address _spender
                         )
                          public
                          view
                          returns (uint256)
                        {
                          return allowed[_owner][_spender];
                        }
                      
                        /**
                         * @dev Increase the amount of tokens that an owner allowed to a spender.
                         * approve should be called when allowed[_spender] == 0. To increment
                         * allowed value is better to use this function to avoid 2 calls (and wait until
                         * the first transaction is mined)
                         * From MonolithDAO Token.sol
                         * @param _spender The address which will spend the funds.
                         * @param _addedValue The amount of tokens to increase the allowance by.
                         */
                        function increaseApproval(
                          address _spender,
                          uint256 _addedValue
                        )
                          public
                          returns (bool)
                        {
                          allowed[msg.sender][_spender] = (
                            allowed[msg.sender][_spender].add(_addedValue));
                          emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
                          return true;
                        }
                      
                        /**
                         * @dev Decrease the amount of tokens that an owner allowed to a spender.
                         * approve should be called when allowed[_spender] == 0. To decrement
                         * allowed value is better to use this function to avoid 2 calls (and wait until
                         * the first transaction is mined)
                         * From MonolithDAO Token.sol
                         * @param _spender The address which will spend the funds.
                         * @param _subtractedValue The amount of tokens to decrease the allowance by.
                         */
                        function decreaseApproval(
                          address _spender,
                          uint256 _subtractedValue
                        )
                          public
                          returns (bool)
                        {
                          uint256 oldValue = allowed[msg.sender][_spender];
                          if (_subtractedValue >= oldValue) {
                            allowed[msg.sender][_spender] = 0;
                          } else {
                            allowed[msg.sender][_spender] = oldValue.sub(_subtractedValue);
                          }
                          emit Approval(msg.sender, _spender, allowed[msg.sender][_spender]);
                          return true;
                        }
                      
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/DetailedERC20.sol
                      
                      /**
                       * @title DetailedERC20 token
                       * @dev The decimals are only for visualization purposes.
                       * All the operations are done using the smallest and indivisible token unit,
                       * just as on Ethereum all the operations are done in wei.
                       */
                      contract DetailedERC20 is ERC20 {
                        string public name;
                        string public symbol;
                        uint8 public decimals;
                      
                        constructor(string _name, string _symbol, uint8 _decimals) public {
                          name = _name;
                          symbol = _symbol;
                          decimals = _decimals;
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/ownership/Ownable.sol
                      
                      /**
                       * @title Ownable
                       * @dev The Ownable contract has an owner address, and provides basic authorization control
                       * functions, this simplifies the implementation of "user permissions".
                       */
                      contract Ownable {
                        address public owner;
                      
                      
                        event OwnershipRenounced(address indexed previousOwner);
                        event OwnershipTransferred(
                          address indexed previousOwner,
                          address indexed newOwner
                        );
                      
                      
                        /**
                         * @dev The Ownable constructor sets the original `owner` of the contract to the sender
                         * account.
                         */
                        constructor() public {
                          owner = msg.sender;
                        }
                      
                        /**
                         * @dev Throws if called by any account other than the owner.
                         */
                        modifier onlyOwner() {
                          require(msg.sender == owner);
                          _;
                        }
                      
                        /**
                         * @dev Allows the current owner to relinquish control of the contract.
                         * @notice Renouncing to ownership will leave the contract without an owner.
                         * It will not be possible to call the functions with the `onlyOwner`
                         * modifier anymore.
                         */
                        function renounceOwnership() public onlyOwner {
                          emit OwnershipRenounced(owner);
                          owner = address(0);
                        }
                      
                        /**
                         * @dev Allows the current owner to transfer control of the contract to a newOwner.
                         * @param _newOwner The address to transfer ownership to.
                         */
                        function transferOwnership(address _newOwner) public onlyOwner {
                          _transferOwnership(_newOwner);
                        }
                      
                        /**
                         * @dev Transfers control of the contract to a newOwner.
                         * @param _newOwner The address to transfer ownership to.
                         */
                        function _transferOwnership(address _newOwner) internal {
                          require(_newOwner != address(0));
                          emit OwnershipTransferred(owner, _newOwner);
                          owner = _newOwner;
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/MintableToken.sol
                      
                      /**
                       * @title Mintable token
                       * @dev Simple ERC20 Token example, with mintable token creation
                       * Based on code by TokenMarketNet: https://github.com/TokenMarketNet/ico/blob/master/contracts/MintableToken.sol
                       */
                      contract MintableToken is StandardToken, Ownable {
                        event Mint(address indexed to, uint256 amount);
                        event MintFinished();
                      
                        bool public mintingFinished = false;
                      
                      
                        modifier canMint() {
                          require(!mintingFinished);
                          _;
                        }
                      
                        modifier hasMintPermission() {
                          require(msg.sender == owner);
                          _;
                        }
                      
                        /**
                         * @dev Function to mint tokens
                         * @param _to The address that will receive the minted tokens.
                         * @param _amount The amount of tokens to mint.
                         * @return A boolean that indicates if the operation was successful.
                         */
                        function mint(
                          address _to,
                          uint256 _amount
                        )
                          public
                          hasMintPermission
                          canMint
                          returns (bool)
                        {
                          totalSupply_ = totalSupply_.add(_amount);
                          balances[_to] = balances[_to].add(_amount);
                          emit Mint(_to, _amount);
                          emit Transfer(address(0), _to, _amount);
                          return true;
                        }
                      
                        /**
                         * @dev Function to stop minting new tokens.
                         * @return True if the operation was successful.
                         */
                        function finishMinting() public onlyOwner canMint returns (bool) {
                          mintingFinished = true;
                          emit MintFinished();
                          return true;
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/BurnableToken.sol
                      
                      /**
                       * @title Burnable Token
                       * @dev Token that can be irreversibly burned (destroyed).
                       */
                      contract BurnableToken is BasicToken {
                      
                        event Burn(address indexed burner, uint256 value);
                      
                        /**
                         * @dev Burns a specific amount of tokens.
                         * @param _value The amount of token to be burned.
                         */
                        function burn(uint256 _value) public {
                          _burn(msg.sender, _value);
                        }
                      
                        function _burn(address _who, uint256 _value) internal {
                          require(_value <= balances[_who]);
                          // no need to require value <= totalSupply, since that would imply the
                          // sender's balance is greater than the totalSupply, which *should* be an assertion failure
                      
                          balances[_who] = balances[_who].sub(_value);
                          totalSupply_ = totalSupply_.sub(_value);
                          emit Burn(_who, _value);
                          emit Transfer(_who, address(0), _value);
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/lifecycle/Pausable.sol
                      
                      /**
                       * @title Pausable
                       * @dev Base contract which allows children to implement an emergency stop mechanism.
                       */
                      contract Pausable is Ownable {
                        event Pause();
                        event Unpause();
                      
                        bool public paused = false;
                      
                      
                        /**
                         * @dev Modifier to make a function callable only when the contract is not paused.
                         */
                        modifier whenNotPaused() {
                          require(!paused);
                          _;
                        }
                      
                        /**
                         * @dev Modifier to make a function callable only when the contract is paused.
                         */
                        modifier whenPaused() {
                          require(paused);
                          _;
                        }
                      
                        /**
                         * @dev called by the owner to pause, triggers stopped state
                         */
                        function pause() public onlyOwner whenNotPaused {
                          paused = true;
                          emit Pause();
                        }
                      
                        /**
                         * @dev called by the owner to unpause, returns to normal state
                         */
                        function unpause() public onlyOwner whenPaused {
                          paused = false;
                          emit Unpause();
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/PausableToken.sol
                      
                      /**
                       * @title Pausable token
                       * @dev StandardToken modified with pausable transfers.
                       **/
                      contract PausableToken is StandardToken, Pausable {
                      
                        function transfer(
                          address _to,
                          uint256 _value
                        )
                          public
                          whenNotPaused
                          returns (bool)
                        {
                          return super.transfer(_to, _value);
                        }
                      
                        function transferFrom(
                          address _from,
                          address _to,
                          uint256 _value
                        )
                          public
                          whenNotPaused
                          returns (bool)
                        {
                          return super.transferFrom(_from, _to, _value);
                        }
                      
                        function approve(
                          address _spender,
                          uint256 _value
                        )
                          public
                          whenNotPaused
                          returns (bool)
                        {
                          return super.approve(_spender, _value);
                        }
                      
                        function increaseApproval(
                          address _spender,
                          uint _addedValue
                        )
                          public
                          whenNotPaused
                          returns (bool success)
                        {
                          return super.increaseApproval(_spender, _addedValue);
                        }
                      
                        function decreaseApproval(
                          address _spender,
                          uint _subtractedValue
                        )
                          public
                          whenNotPaused
                          returns (bool success)
                        {
                          return super.decreaseApproval(_spender, _subtractedValue);
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/ownership/Claimable.sol
                      
                      /**
                       * @title Claimable
                       * @dev Extension for the Ownable contract, where the ownership needs to be claimed.
                       * This allows the new owner to accept the transfer.
                       */
                      contract Claimable is Ownable {
                        address public pendingOwner;
                      
                        /**
                         * @dev Modifier throws if called by any account other than the pendingOwner.
                         */
                        modifier onlyPendingOwner() {
                          require(msg.sender == pendingOwner);
                          _;
                        }
                      
                        /**
                         * @dev Allows the current owner to set the pendingOwner address.
                         * @param newOwner The address to transfer ownership to.
                         */
                        function transferOwnership(address newOwner) public onlyOwner {
                          pendingOwner = newOwner;
                        }
                      
                        /**
                         * @dev Allows the pendingOwner address to finalize the transfer.
                         */
                        function claimOwnership() public onlyPendingOwner {
                          emit OwnershipTransferred(owner, pendingOwner);
                          owner = pendingOwner;
                          pendingOwner = address(0);
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/token/ERC20/SafeERC20.sol
                      
                      /**
                       * @title SafeERC20
                       * @dev Wrappers around ERC20 operations that throw on failure.
                       * To use this library you can add a `using SafeERC20 for ERC20;` statement to your contract,
                       * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
                       */
                      library SafeERC20 {
                        function safeTransfer(
                          ERC20Basic _token,
                          address _to,
                          uint256 _value
                        )
                          internal
                        {
                          require(_token.transfer(_to, _value));
                        }
                      
                        function safeTransferFrom(
                          ERC20 _token,
                          address _from,
                          address _to,
                          uint256 _value
                        )
                          internal
                        {
                          require(_token.transferFrom(_from, _to, _value));
                        }
                      
                        function safeApprove(
                          ERC20 _token,
                          address _spender,
                          uint256 _value
                        )
                          internal
                        {
                          require(_token.approve(_spender, _value));
                        }
                      }
                      
                      // File: openzeppelin-solidity/contracts/ownership/CanReclaimToken.sol
                      
                      /**
                       * @title Contracts that should be able to recover tokens
                       * @author SylTi
                       * @dev This allow a contract to recover any ERC20 token received in a contract by transferring the balance to the contract owner.
                       * This will prevent any accidental loss of tokens.
                       */
                      contract CanReclaimToken is Ownable {
                        using SafeERC20 for ERC20Basic;
                      
                        /**
                         * @dev Reclaim all ERC20Basic compatible tokens
                         * @param _token ERC20Basic The address of the token contract
                         */
                        function reclaimToken(ERC20Basic _token) external onlyOwner {
                          uint256 balance = _token.balanceOf(this);
                          _token.safeTransfer(owner, balance);
                        }
                      
                      }
                      
                      // File: contracts/utils/OwnableContract.sol
                      
                      // empty block is used as this contract just inherits others.
                      contract OwnableContract is CanReclaimToken, Claimable { } /* solhint-disable-line no-empty-blocks */
                      
                      // File: contracts/token/WBTC.sol
                      
                      contract WBTC is StandardToken, DetailedERC20("Wrapped BTC", "WBTC", 8),
                          MintableToken, BurnableToken, PausableToken, OwnableContract {
                      
                          function burn(uint value) public onlyOwner {
                              super.burn(value);
                          }
                      
                          function finishMinting() public onlyOwner returns (bool) {
                              return false;
                          }
                      
                          function renounceOwnership() public onlyOwner {
                              revert("renouncing ownership is blocked");
                          }
                      }

                      File 4 of 9: TransparentUpgradeableProxy
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.3) (proxy/transparent/TransparentUpgradeableProxy.sol)
                      pragma solidity ^0.8.0;
                      import "ERC1967Proxy.sol";
                      /**
                       * @dev Interface for {TransparentUpgradeableProxy}. In order to implement transparency, {TransparentUpgradeableProxy}
                       * does not implement this interface directly, and some of its functions are implemented by an internal dispatch
                       * mechanism. The compiler is unaware that these functions are implemented by {TransparentUpgradeableProxy} and will not
                       * include them in the ABI so this interface must be used to interact with it.
                       */
                      interface ITransparentUpgradeableProxy is IERC1967 {
                          function admin() external view returns (address);
                          function implementation() external view returns (address);
                          function changeAdmin(address) external;
                          function upgradeTo(address) external;
                          function upgradeToAndCall(address, bytes memory) external payable;
                      }
                      /**
                       * @dev This contract implements a proxy that is upgradeable by an admin.
                       *
                       * To avoid https://medium.com/nomic-labs-blog/malicious-backdoors-in-ethereum-proxies-62629adf3357[proxy selector
                       * clashing], which can potentially be used in an attack, this contract uses the
                       * https://blog.openzeppelin.com/the-transparent-proxy-pattern/[transparent proxy pattern]. This pattern implies two
                       * things that go hand in hand:
                       *
                       * 1. If any account other than the admin calls the proxy, the call will be forwarded to the implementation, even if
                       * that call matches one of the admin functions exposed by the proxy itself.
                       * 2. If the admin calls the proxy, it can access the admin functions, but its calls will never be forwarded to the
                       * implementation. If the admin tries to call a function on the implementation it will fail with an error that says
                       * "admin cannot fallback to proxy target".
                       *
                       * These properties mean that the admin account can only be used for admin actions like upgrading the proxy or changing
                       * the admin, so it's best if it's a dedicated account that is not used for anything else. This will avoid headaches due
                       * to sudden errors when trying to call a function from the proxy implementation.
                       *
                       * Our recommendation is for the dedicated account to be an instance of the {ProxyAdmin} contract. If set up this way,
                       * you should think of the `ProxyAdmin` instance as the real administrative interface of your proxy.
                       *
                       * NOTE: The real interface of this proxy is that defined in `ITransparentUpgradeableProxy`. This contract does not
                       * inherit from that interface, and instead the admin functions are implicitly implemented using a custom dispatch
                       * mechanism in `_fallback`. Consequently, the compiler will not produce an ABI for this contract. This is necessary to
                       * fully implement transparency without decoding reverts caused by selector clashes between the proxy and the
                       * implementation.
                       *
                       * WARNING: It is not recommended to extend this contract to add additional external functions. If you do so, the compiler
                       * will not check that there are no selector conflicts, due to the note above. A selector clash between any new function
                       * and the functions declared in {ITransparentUpgradeableProxy} will be resolved in favor of the new one. This could
                       * render the admin operations inaccessible, which could prevent upgradeability. Transparency may also be compromised.
                       */
                      contract TransparentUpgradeableProxy is ERC1967Proxy {
                          /**
                           * @dev Initializes an upgradeable proxy managed by `_admin`, backed by the implementation at `_logic`, and
                           * optionally initialized with `_data` as explained in {ERC1967Proxy-constructor}.
                           */
                          constructor(
                              address _logic,
                              address admin_,
                              bytes memory _data
                          ) payable ERC1967Proxy(_logic, _data) {
                              _changeAdmin(admin_);
                          }
                          /**
                           * @dev Modifier used internally that will delegate the call to the implementation unless the sender is the admin.
                           *
                           * CAUTION: This modifier is deprecated, as it could cause issues if the modified function has arguments, and the
                           * implementation provides a function with the same selector.
                           */
                          modifier ifAdmin() {
                              if (msg.sender == _getAdmin()) {
                                  _;
                              } else {
                                  _fallback();
                              }
                          }
                          /**
                           * @dev If caller is the admin process the call internally, otherwise transparently fallback to the proxy behavior
                           */
                          function _fallback() internal virtual override {
                              if (msg.sender == _getAdmin()) {
                                  bytes memory ret;
                                  bytes4 selector = msg.sig;
                                  if (selector == ITransparentUpgradeableProxy.upgradeTo.selector) {
                                      ret = _dispatchUpgradeTo();
                                  } else if (selector == ITransparentUpgradeableProxy.upgradeToAndCall.selector) {
                                      ret = _dispatchUpgradeToAndCall();
                                  } else if (selector == ITransparentUpgradeableProxy.changeAdmin.selector) {
                                      ret = _dispatchChangeAdmin();
                                  } else if (selector == ITransparentUpgradeableProxy.admin.selector) {
                                      ret = _dispatchAdmin();
                                  } else if (selector == ITransparentUpgradeableProxy.implementation.selector) {
                                      ret = _dispatchImplementation();
                                  } else {
                                      revert("TransparentUpgradeableProxy: admin cannot fallback to proxy target");
                                  }
                                  assembly {
                                      return(add(ret, 0x20), mload(ret))
                                  }
                              } else {
                                  super._fallback();
                              }
                          }
                          /**
                           * @dev Returns the current admin.
                           *
                           * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                           * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                           * `0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103`
                           */
                          function _dispatchAdmin() private returns (bytes memory) {
                              _requireZeroValue();
                              address admin = _getAdmin();
                              return abi.encode(admin);
                          }
                          /**
                           * @dev Returns the current implementation.
                           *
                           * TIP: To get this value clients can read directly from the storage slot shown below (specified by EIP1967) using the
                           * https://eth.wiki/json-rpc/API#eth_getstorageat[`eth_getStorageAt`] RPC call.
                           * `0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc`
                           */
                          function _dispatchImplementation() private returns (bytes memory) {
                              _requireZeroValue();
                              address implementation = _implementation();
                              return abi.encode(implementation);
                          }
                          /**
                           * @dev Changes the admin of the proxy.
                           *
                           * Emits an {AdminChanged} event.
                           */
                          function _dispatchChangeAdmin() private returns (bytes memory) {
                              _requireZeroValue();
                              address newAdmin = abi.decode(msg.data[4:], (address));
                              _changeAdmin(newAdmin);
                              return "";
                          }
                          /**
                           * @dev Upgrade the implementation of the proxy.
                           */
                          function _dispatchUpgradeTo() private returns (bytes memory) {
                              _requireZeroValue();
                              address newImplementation = abi.decode(msg.data[4:], (address));
                              _upgradeToAndCall(newImplementation, bytes(""), false);
                              return "";
                          }
                          /**
                           * @dev Upgrade the implementation of the proxy, and then call a function from the new implementation as specified
                           * by `data`, which should be an encoded function call. This is useful to initialize new storage variables in the
                           * proxied contract.
                           */
                          function _dispatchUpgradeToAndCall() private returns (bytes memory) {
                              (address newImplementation, bytes memory data) = abi.decode(msg.data[4:], (address, bytes));
                              _upgradeToAndCall(newImplementation, data, true);
                              return "";
                          }
                          /**
                           * @dev Returns the current admin.
                           */
                          function _admin() internal view virtual returns (address) {
                              return _getAdmin();
                          }
                          /**
                           * @dev To keep this contract fully transparent, all `ifAdmin` functions must be payable. This helper is here to
                           * emulate some proxy functions being non-payable while still allowing value to pass through.
                           */
                          function _requireZeroValue() private {
                              require(msg.value == 0);
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.7.0) (proxy/ERC1967/ERC1967Proxy.sol)
                      pragma solidity ^0.8.0;
                      import "Proxy.sol";
                      import "ERC1967Upgrade.sol";
                      /**
                       * @dev This contract implements an upgradeable proxy. It is upgradeable because calls are delegated to an
                       * implementation address that can be changed. This address is stored in storage in the location specified by
                       * https://eips.ethereum.org/EIPS/eip-1967[EIP1967], so that it doesn't conflict with the storage layout of the
                       * implementation behind the proxy.
                       */
                      contract ERC1967Proxy is Proxy, ERC1967Upgrade {
                          /**
                           * @dev Initializes the upgradeable proxy with an initial implementation specified by `_logic`.
                           *
                           * If `_data` is nonempty, it's used as data in a delegate call to `_logic`. This will typically be an encoded
                           * function call, and allows initializing the storage of the proxy like a Solidity constructor.
                           */
                          constructor(address _logic, bytes memory _data) payable {
                              _upgradeToAndCall(_logic, _data, false);
                          }
                          /**
                           * @dev Returns the current implementation address.
                           */
                          function _implementation() internal view virtual override returns (address impl) {
                              return ERC1967Upgrade._getImplementation();
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.6.0) (proxy/Proxy.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev This abstract contract provides a fallback function that delegates all calls to another contract using the EVM
                       * instruction `delegatecall`. We refer to the second contract as the _implementation_ behind the proxy, and it has to
                       * be specified by overriding the virtual {_implementation} function.
                       *
                       * Additionally, delegation to the implementation can be triggered manually through the {_fallback} function, or to a
                       * different contract through the {_delegate} function.
                       *
                       * The success and return data of the delegated call will be returned back to the caller of the proxy.
                       */
                      abstract contract Proxy {
                          /**
                           * @dev Delegates the current call to `implementation`.
                           *
                           * This function does not return to its internal call site, it will return directly to the external caller.
                           */
                          function _delegate(address implementation) internal virtual {
                              assembly {
                                  // Copy msg.data. We take full control of memory in this inline assembly
                                  // block because it will not return to Solidity code. We overwrite the
                                  // Solidity scratch pad at memory position 0.
                                  calldatacopy(0, 0, calldatasize())
                                  // Call the implementation.
                                  // out and outsize are 0 because we don't know the size yet.
                                  let result := delegatecall(gas(), implementation, 0, calldatasize(), 0, 0)
                                  // Copy the returned data.
                                  returndatacopy(0, 0, returndatasize())
                                  switch result
                                  // delegatecall returns 0 on error.
                                  case 0 {
                                      revert(0, returndatasize())
                                  }
                                  default {
                                      return(0, returndatasize())
                                  }
                              }
                          }
                          /**
                           * @dev This is a virtual function that should be overridden so it returns the address to which the fallback function
                           * and {_fallback} should delegate.
                           */
                          function _implementation() internal view virtual returns (address);
                          /**
                           * @dev Delegates the current call to the address returned by `_implementation()`.
                           *
                           * This function does not return to its internal call site, it will return directly to the external caller.
                           */
                          function _fallback() internal virtual {
                              _beforeFallback();
                              _delegate(_implementation());
                          }
                          /**
                           * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if no other
                           * function in the contract matches the call data.
                           */
                          fallback() external payable virtual {
                              _fallback();
                          }
                          /**
                           * @dev Fallback function that delegates calls to the address returned by `_implementation()`. Will run if call data
                           * is empty.
                           */
                          receive() external payable virtual {
                              _fallback();
                          }
                          /**
                           * @dev Hook that is called before falling back to the implementation. Can happen as part of a manual `_fallback`
                           * call, or as part of the Solidity `fallback` or `receive` functions.
                           *
                           * If overridden should call `super._beforeFallback()`.
                           */
                          function _beforeFallback() internal virtual {}
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.3) (proxy/ERC1967/ERC1967Upgrade.sol)
                      pragma solidity ^0.8.2;
                      import "IBeacon.sol";
                      import "IERC1967.sol";
                      import "draft-IERC1822.sol";
                      import "Address.sol";
                      import "StorageSlot.sol";
                      /**
                       * @dev This abstract contract provides getters and event emitting update functions for
                       * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
                       *
                       * _Available since v4.1._
                       *
                       * @custom:oz-upgrades-unsafe-allow delegatecall
                       */
                      abstract contract ERC1967Upgrade is IERC1967 {
                          // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
                          bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;
                          /**
                           * @dev Storage slot with the address of the current implementation.
                           * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
                           * validated in the constructor.
                           */
                          bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                          /**
                           * @dev Returns the current implementation address.
                           */
                          function _getImplementation() internal view returns (address) {
                              return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                          }
                          /**
                           * @dev Stores a new address in the EIP1967 implementation slot.
                           */
                          function _setImplementation(address newImplementation) private {
                              require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                              StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
                          }
                          /**
                           * @dev Perform implementation upgrade
                           *
                           * Emits an {Upgraded} event.
                           */
                          function _upgradeTo(address newImplementation) internal {
                              _setImplementation(newImplementation);
                              emit Upgraded(newImplementation);
                          }
                          /**
                           * @dev Perform implementation upgrade with additional setup call.
                           *
                           * Emits an {Upgraded} event.
                           */
                          function _upgradeToAndCall(
                              address newImplementation,
                              bytes memory data,
                              bool forceCall
                          ) internal {
                              _upgradeTo(newImplementation);
                              if (data.length > 0 || forceCall) {
                                  Address.functionDelegateCall(newImplementation, data);
                              }
                          }
                          /**
                           * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
                           *
                           * Emits an {Upgraded} event.
                           */
                          function _upgradeToAndCallUUPS(
                              address newImplementation,
                              bytes memory data,
                              bool forceCall
                          ) internal {
                              // Upgrades from old implementations will perform a rollback test. This test requires the new
                              // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
                              // this special case will break upgrade paths from old UUPS implementation to new ones.
                              if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
                                  _setImplementation(newImplementation);
                              } else {
                                  try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                                      require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
                                  } catch {
                                      revert("ERC1967Upgrade: new implementation is not UUPS");
                                  }
                                  _upgradeToAndCall(newImplementation, data, forceCall);
                              }
                          }
                          /**
                           * @dev Storage slot with the admin of the contract.
                           * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
                           * validated in the constructor.
                           */
                          bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;
                          /**
                           * @dev Returns the current admin.
                           */
                          function _getAdmin() internal view returns (address) {
                              return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
                          }
                          /**
                           * @dev Stores a new address in the EIP1967 admin slot.
                           */
                          function _setAdmin(address newAdmin) private {
                              require(newAdmin != address(0), "ERC1967: new admin is the zero address");
                              StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
                          }
                          /**
                           * @dev Changes the admin of the proxy.
                           *
                           * Emits an {AdminChanged} event.
                           */
                          function _changeAdmin(address newAdmin) internal {
                              emit AdminChanged(_getAdmin(), newAdmin);
                              _setAdmin(newAdmin);
                          }
                          /**
                           * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
                           * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
                           */
                          bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;
                          /**
                           * @dev Returns the current beacon.
                           */
                          function _getBeacon() internal view returns (address) {
                              return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
                          }
                          /**
                           * @dev Stores a new beacon in the EIP1967 beacon slot.
                           */
                          function _setBeacon(address newBeacon) private {
                              require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
                              require(
                                  Address.isContract(IBeacon(newBeacon).implementation()),
                                  "ERC1967: beacon implementation is not a contract"
                              );
                              StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
                          }
                          /**
                           * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
                           * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
                           *
                           * Emits a {BeaconUpgraded} event.
                           */
                          function _upgradeBeaconToAndCall(
                              address newBeacon,
                              bytes memory data,
                              bool forceCall
                          ) internal {
                              _setBeacon(newBeacon);
                              emit BeaconUpgraded(newBeacon);
                              if (data.length > 0 || forceCall) {
                                  Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev This is the interface that {BeaconProxy} expects of its beacon.
                       */
                      interface IBeacon {
                          /**
                           * @dev Must return an address that can be used as a delegate call target.
                           *
                           * {BeaconProxy} will check that this address is a contract.
                           */
                          function implementation() external view returns (address);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.3) (interfaces/IERC1967.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
                       *
                       * _Available since v4.9._
                       */
                      interface IERC1967 {
                          /**
                           * @dev Emitted when the implementation is upgraded.
                           */
                          event Upgraded(address indexed implementation);
                          /**
                           * @dev Emitted when the admin account has changed.
                           */
                          event AdminChanged(address previousAdmin, address newAdmin);
                          /**
                           * @dev Emitted when the beacon is changed.
                           */
                          event BeaconUpgraded(address indexed beacon);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
                       * proxy whose upgrades are fully controlled by the current implementation.
                       */
                      interface IERC1822Proxiable {
                          /**
                           * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
                           * address.
                           *
                           * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
                           * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
                           * function revert if invoked through a proxy.
                           */
                          function proxiableUUID() external view returns (bytes32);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
                      pragma solidity ^0.8.1;
                      /**
                       * @dev Collection of functions related to the address type
                       */
                      library Address {
                          /**
                           * @dev Returns true if `account` is a contract.
                           *
                           * [IMPORTANT]
                           * ====
                           * It is unsafe to assume that an address for which this function returns
                           * false is an externally-owned account (EOA) and not a contract.
                           *
                           * Among others, `isContract` will return false for the following
                           * types of addresses:
                           *
                           *  - an externally-owned account
                           *  - a contract in construction
                           *  - an address where a contract will be created
                           *  - an address where a contract lived, but was destroyed
                           * ====
                           *
                           * [IMPORTANT]
                           * ====
                           * You shouldn't rely on `isContract` to protect against flash loan attacks!
                           *
                           * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
                           * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
                           * constructor.
                           * ====
                           */
                          function isContract(address account) internal view returns (bool) {
                              // This method relies on extcodesize/address.code.length, which returns 0
                              // for contracts in construction, since the code is only stored at the end
                              // of the constructor execution.
                              return account.code.length > 0;
                          }
                          /**
                           * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                           * `recipient`, forwarding all available gas and reverting on errors.
                           *
                           * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                           * of certain opcodes, possibly making contracts go over the 2300 gas limit
                           * imposed by `transfer`, making them unable to receive funds via
                           * `transfer`. {sendValue} removes this limitation.
                           *
                           * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                           *
                           * IMPORTANT: because control is transferred to `recipient`, care must be
                           * taken to not create reentrancy vulnerabilities. Consider using
                           * {ReentrancyGuard} or the
                           * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                           */
                          function sendValue(address payable recipient, uint256 amount) internal {
                              require(address(this).balance >= amount, "Address: insufficient balance");
                              (bool success, ) = recipient.call{value: amount}("");
                              require(success, "Address: unable to send value, recipient may have reverted");
                          }
                          /**
                           * @dev Performs a Solidity function call using a low level `call`. A
                           * plain `call` is an unsafe replacement for a function call: use this
                           * function instead.
                           *
                           * If `target` reverts with a revert reason, it is bubbled up by this
                           * function (like regular Solidity function calls).
                           *
                           * Returns the raw returned data. To convert to the expected return value,
                           * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                           *
                           * Requirements:
                           *
                           * - `target` must be a contract.
                           * - calling `target` with `data` must not revert.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, "Address: low-level call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                           * `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but also transferring `value` wei to `target`.
                           *
                           * Requirements:
                           *
                           * - the calling contract must have an ETH balance of at least `value`.
                           * - the called Solidity function must be `payable`.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                           * with `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              require(address(this).balance >= value, "Address: insufficient balance for call");
                              (bool success, bytes memory returndata) = target.call{value: value}(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                              return functionStaticCall(target, data, "Address: low-level static call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              (bool success, bytes memory returndata) = target.staticcall(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but performing a delegate call.
                           *
                           * _Available since v3.4._
                           */
                          function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
                              return functionDelegateCall(target, data, "Address: low-level delegate call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                           * but performing a delegate call.
                           *
                           * _Available since v3.4._
                           */
                          function functionDelegateCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              (bool success, bytes memory returndata) = target.delegatecall(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
                           * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
                           *
                           * _Available since v4.8._
                           */
                          function verifyCallResultFromTarget(
                              address target,
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              if (success) {
                                  if (returndata.length == 0) {
                                      // only check isContract if the call was successful and the return data is empty
                                      // otherwise we already know that it was a contract
                                      require(isContract(target), "Address: call to non-contract");
                                  }
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          /**
                           * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
                           * revert reason or using the provided one.
                           *
                           * _Available since v4.3._
                           */
                          function verifyCallResult(
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal pure returns (bytes memory) {
                              if (success) {
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          function _revert(bytes memory returndata, string memory errorMessage) private pure {
                              // Look for revert reason and bubble it up if present
                              if (returndata.length > 0) {
                                  // The easiest way to bubble the revert reason is using memory via assembly
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      let returndata_size := mload(returndata)
                                      revert(add(32, returndata), returndata_size)
                                  }
                              } else {
                                  revert(errorMessage);
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.7.0) (utils/StorageSlot.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Library for reading and writing primitive types to specific storage slots.
                       *
                       * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
                       * This library helps with reading and writing to such slots without the need for inline assembly.
                       *
                       * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
                       *
                       * Example usage to set ERC1967 implementation slot:
                       * ```
                       * contract ERC1967 {
                       *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
                       *
                       *     function _getImplementation() internal view returns (address) {
                       *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
                       *     }
                       *
                       *     function _setImplementation(address newImplementation) internal {
                       *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
                       *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
                       *     }
                       * }
                       * ```
                       *
                       * _Available since v4.1 for `address`, `bool`, `bytes32`, and `uint256`._
                       */
                      library StorageSlot {
                          struct AddressSlot {
                              address value;
                          }
                          struct BooleanSlot {
                              bool value;
                          }
                          struct Bytes32Slot {
                              bytes32 value;
                          }
                          struct Uint256Slot {
                              uint256 value;
                          }
                          /**
                           * @dev Returns an `AddressSlot` with member `value` located at `slot`.
                           */
                          function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  r.slot := slot
                              }
                          }
                          /**
                           * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
                           */
                          function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  r.slot := slot
                              }
                          }
                          /**
                           * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
                           */
                          function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  r.slot := slot
                              }
                          }
                          /**
                           * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
                           */
                          function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  r.slot := slot
                              }
                          }
                      }
                      

                      File 5 of 9: UniswapV3Pool
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity =0.7.6;
                      import './interfaces/IUniswapV3Pool.sol';
                      import './NoDelegateCall.sol';
                      import './libraries/LowGasSafeMath.sol';
                      import './libraries/SafeCast.sol';
                      import './libraries/Tick.sol';
                      import './libraries/TickBitmap.sol';
                      import './libraries/Position.sol';
                      import './libraries/Oracle.sol';
                      import './libraries/FullMath.sol';
                      import './libraries/FixedPoint128.sol';
                      import './libraries/TransferHelper.sol';
                      import './libraries/TickMath.sol';
                      import './libraries/LiquidityMath.sol';
                      import './libraries/SqrtPriceMath.sol';
                      import './libraries/SwapMath.sol';
                      import './interfaces/IUniswapV3PoolDeployer.sol';
                      import './interfaces/IUniswapV3Factory.sol';
                      import './interfaces/IERC20Minimal.sol';
                      import './interfaces/callback/IUniswapV3MintCallback.sol';
                      import './interfaces/callback/IUniswapV3SwapCallback.sol';
                      import './interfaces/callback/IUniswapV3FlashCallback.sol';
                      contract UniswapV3Pool is IUniswapV3Pool, NoDelegateCall {
                          using LowGasSafeMath for uint256;
                          using LowGasSafeMath for int256;
                          using SafeCast for uint256;
                          using SafeCast for int256;
                          using Tick for mapping(int24 => Tick.Info);
                          using TickBitmap for mapping(int16 => uint256);
                          using Position for mapping(bytes32 => Position.Info);
                          using Position for Position.Info;
                          using Oracle for Oracle.Observation[65535];
                          /// @inheritdoc IUniswapV3PoolImmutables
                          address public immutable override factory;
                          /// @inheritdoc IUniswapV3PoolImmutables
                          address public immutable override token0;
                          /// @inheritdoc IUniswapV3PoolImmutables
                          address public immutable override token1;
                          /// @inheritdoc IUniswapV3PoolImmutables
                          uint24 public immutable override fee;
                          /// @inheritdoc IUniswapV3PoolImmutables
                          int24 public immutable override tickSpacing;
                          /// @inheritdoc IUniswapV3PoolImmutables
                          uint128 public immutable override maxLiquidityPerTick;
                          struct Slot0 {
                              // the current price
                              uint160 sqrtPriceX96;
                              // the current tick
                              int24 tick;
                              // the most-recently updated index of the observations array
                              uint16 observationIndex;
                              // the current maximum number of observations that are being stored
                              uint16 observationCardinality;
                              // the next maximum number of observations to store, triggered in observations.write
                              uint16 observationCardinalityNext;
                              // the current protocol fee as a percentage of the swap fee taken on withdrawal
                              // represented as an integer denominator (1/x)%
                              uint8 feeProtocol;
                              // whether the pool is locked
                              bool unlocked;
                          }
                          /// @inheritdoc IUniswapV3PoolState
                          Slot0 public override slot0;
                          /// @inheritdoc IUniswapV3PoolState
                          uint256 public override feeGrowthGlobal0X128;
                          /// @inheritdoc IUniswapV3PoolState
                          uint256 public override feeGrowthGlobal1X128;
                          // accumulated protocol fees in token0/token1 units
                          struct ProtocolFees {
                              uint128 token0;
                              uint128 token1;
                          }
                          /// @inheritdoc IUniswapV3PoolState
                          ProtocolFees public override protocolFees;
                          /// @inheritdoc IUniswapV3PoolState
                          uint128 public override liquidity;
                          /// @inheritdoc IUniswapV3PoolState
                          mapping(int24 => Tick.Info) public override ticks;
                          /// @inheritdoc IUniswapV3PoolState
                          mapping(int16 => uint256) public override tickBitmap;
                          /// @inheritdoc IUniswapV3PoolState
                          mapping(bytes32 => Position.Info) public override positions;
                          /// @inheritdoc IUniswapV3PoolState
                          Oracle.Observation[65535] public override observations;
                          /// @dev Mutually exclusive reentrancy protection into the pool to/from a method. This method also prevents entrance
                          /// to a function before the pool is initialized. The reentrancy guard is required throughout the contract because
                          /// we use balance checks to determine the payment status of interactions such as mint, swap and flash.
                          modifier lock() {
                              require(slot0.unlocked, 'LOK');
                              slot0.unlocked = false;
                              _;
                              slot0.unlocked = true;
                          }
                          /// @dev Prevents calling a function from anyone except the address returned by IUniswapV3Factory#owner()
                          modifier onlyFactoryOwner() {
                              require(msg.sender == IUniswapV3Factory(factory).owner());
                              _;
                          }
                          constructor() {
                              int24 _tickSpacing;
                              (factory, token0, token1, fee, _tickSpacing) = IUniswapV3PoolDeployer(msg.sender).parameters();
                              tickSpacing = _tickSpacing;
                              maxLiquidityPerTick = Tick.tickSpacingToMaxLiquidityPerTick(_tickSpacing);
                          }
                          /// @dev Common checks for valid tick inputs.
                          function checkTicks(int24 tickLower, int24 tickUpper) private pure {
                              require(tickLower < tickUpper, 'TLU');
                              require(tickLower >= TickMath.MIN_TICK, 'TLM');
                              require(tickUpper <= TickMath.MAX_TICK, 'TUM');
                          }
                          /// @dev Returns the block timestamp truncated to 32 bits, i.e. mod 2**32. This method is overridden in tests.
                          function _blockTimestamp() internal view virtual returns (uint32) {
                              return uint32(block.timestamp); // truncation is desired
                          }
                          /// @dev Get the pool's balance of token0
                          /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize
                          /// check
                          function balance0() private view returns (uint256) {
                              (bool success, bytes memory data) =
                                  token0.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
                              require(success && data.length >= 32);
                              return abi.decode(data, (uint256));
                          }
                          /// @dev Get the pool's balance of token1
                          /// @dev This function is gas optimized to avoid a redundant extcodesize check in addition to the returndatasize
                          /// check
                          function balance1() private view returns (uint256) {
                              (bool success, bytes memory data) =
                                  token1.staticcall(abi.encodeWithSelector(IERC20Minimal.balanceOf.selector, address(this)));
                              require(success && data.length >= 32);
                              return abi.decode(data, (uint256));
                          }
                          /// @inheritdoc IUniswapV3PoolDerivedState
                          function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
                              external
                              view
                              override
                              noDelegateCall
                              returns (
                                  int56 tickCumulativeInside,
                                  uint160 secondsPerLiquidityInsideX128,
                                  uint32 secondsInside
                              )
                          {
                              checkTicks(tickLower, tickUpper);
                              int56 tickCumulativeLower;
                              int56 tickCumulativeUpper;
                              uint160 secondsPerLiquidityOutsideLowerX128;
                              uint160 secondsPerLiquidityOutsideUpperX128;
                              uint32 secondsOutsideLower;
                              uint32 secondsOutsideUpper;
                              {
                                  Tick.Info storage lower = ticks[tickLower];
                                  Tick.Info storage upper = ticks[tickUpper];
                                  bool initializedLower;
                                  (tickCumulativeLower, secondsPerLiquidityOutsideLowerX128, secondsOutsideLower, initializedLower) = (
                                      lower.tickCumulativeOutside,
                                      lower.secondsPerLiquidityOutsideX128,
                                      lower.secondsOutside,
                                      lower.initialized
                                  );
                                  require(initializedLower);
                                  bool initializedUpper;
                                  (tickCumulativeUpper, secondsPerLiquidityOutsideUpperX128, secondsOutsideUpper, initializedUpper) = (
                                      upper.tickCumulativeOutside,
                                      upper.secondsPerLiquidityOutsideX128,
                                      upper.secondsOutside,
                                      upper.initialized
                                  );
                                  require(initializedUpper);
                              }
                              Slot0 memory _slot0 = slot0;
                              if (_slot0.tick < tickLower) {
                                  return (
                                      tickCumulativeLower - tickCumulativeUpper,
                                      secondsPerLiquidityOutsideLowerX128 - secondsPerLiquidityOutsideUpperX128,
                                      secondsOutsideLower - secondsOutsideUpper
                                  );
                              } else if (_slot0.tick < tickUpper) {
                                  uint32 time = _blockTimestamp();
                                  (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =
                                      observations.observeSingle(
                                          time,
                                          0,
                                          _slot0.tick,
                                          _slot0.observationIndex,
                                          liquidity,
                                          _slot0.observationCardinality
                                      );
                                  return (
                                      tickCumulative - tickCumulativeLower - tickCumulativeUpper,
                                      secondsPerLiquidityCumulativeX128 -
                                          secondsPerLiquidityOutsideLowerX128 -
                                          secondsPerLiquidityOutsideUpperX128,
                                      time - secondsOutsideLower - secondsOutsideUpper
                                  );
                              } else {
                                  return (
                                      tickCumulativeUpper - tickCumulativeLower,
                                      secondsPerLiquidityOutsideUpperX128 - secondsPerLiquidityOutsideLowerX128,
                                      secondsOutsideUpper - secondsOutsideLower
                                  );
                              }
                          }
                          /// @inheritdoc IUniswapV3PoolDerivedState
                          function observe(uint32[] calldata secondsAgos)
                              external
                              view
                              override
                              noDelegateCall
                              returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s)
                          {
                              return
                                  observations.observe(
                                      _blockTimestamp(),
                                      secondsAgos,
                                      slot0.tick,
                                      slot0.observationIndex,
                                      liquidity,
                                      slot0.observationCardinality
                                  );
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          function increaseObservationCardinalityNext(uint16 observationCardinalityNext)
                              external
                              override
                              lock
                              noDelegateCall
                          {
                              uint16 observationCardinalityNextOld = slot0.observationCardinalityNext; // for the event
                              uint16 observationCardinalityNextNew =
                                  observations.grow(observationCardinalityNextOld, observationCardinalityNext);
                              slot0.observationCardinalityNext = observationCardinalityNextNew;
                              if (observationCardinalityNextOld != observationCardinalityNextNew)
                                  emit IncreaseObservationCardinalityNext(observationCardinalityNextOld, observationCardinalityNextNew);
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          /// @dev not locked because it initializes unlocked
                          function initialize(uint160 sqrtPriceX96) external override {
                              require(slot0.sqrtPriceX96 == 0, 'AI');
                              int24 tick = TickMath.getTickAtSqrtRatio(sqrtPriceX96);
                              (uint16 cardinality, uint16 cardinalityNext) = observations.initialize(_blockTimestamp());
                              slot0 = Slot0({
                                  sqrtPriceX96: sqrtPriceX96,
                                  tick: tick,
                                  observationIndex: 0,
                                  observationCardinality: cardinality,
                                  observationCardinalityNext: cardinalityNext,
                                  feeProtocol: 0,
                                  unlocked: true
                              });
                              emit Initialize(sqrtPriceX96, tick);
                          }
                          struct ModifyPositionParams {
                              // the address that owns the position
                              address owner;
                              // the lower and upper tick of the position
                              int24 tickLower;
                              int24 tickUpper;
                              // any change in liquidity
                              int128 liquidityDelta;
                          }
                          /// @dev Effect some changes to a position
                          /// @param params the position details and the change to the position's liquidity to effect
                          /// @return position a storage pointer referencing the position with the given owner and tick range
                          /// @return amount0 the amount of token0 owed to the pool, negative if the pool should pay the recipient
                          /// @return amount1 the amount of token1 owed to the pool, negative if the pool should pay the recipient
                          function _modifyPosition(ModifyPositionParams memory params)
                              private
                              noDelegateCall
                              returns (
                                  Position.Info storage position,
                                  int256 amount0,
                                  int256 amount1
                              )
                          {
                              checkTicks(params.tickLower, params.tickUpper);
                              Slot0 memory _slot0 = slot0; // SLOAD for gas optimization
                              position = _updatePosition(
                                  params.owner,
                                  params.tickLower,
                                  params.tickUpper,
                                  params.liquidityDelta,
                                  _slot0.tick
                              );
                              if (params.liquidityDelta != 0) {
                                  if (_slot0.tick < params.tickLower) {
                                      // current tick is below the passed range; liquidity can only become in range by crossing from left to
                                      // right, when we'll need _more_ token0 (it's becoming more valuable) so user must provide it
                                      amount0 = SqrtPriceMath.getAmount0Delta(
                                          TickMath.getSqrtRatioAtTick(params.tickLower),
                                          TickMath.getSqrtRatioAtTick(params.tickUpper),
                                          params.liquidityDelta
                                      );
                                  } else if (_slot0.tick < params.tickUpper) {
                                      // current tick is inside the passed range
                                      uint128 liquidityBefore = liquidity; // SLOAD for gas optimization
                                      // write an oracle entry
                                      (slot0.observationIndex, slot0.observationCardinality) = observations.write(
                                          _slot0.observationIndex,
                                          _blockTimestamp(),
                                          _slot0.tick,
                                          liquidityBefore,
                                          _slot0.observationCardinality,
                                          _slot0.observationCardinalityNext
                                      );
                                      amount0 = SqrtPriceMath.getAmount0Delta(
                                          _slot0.sqrtPriceX96,
                                          TickMath.getSqrtRatioAtTick(params.tickUpper),
                                          params.liquidityDelta
                                      );
                                      amount1 = SqrtPriceMath.getAmount1Delta(
                                          TickMath.getSqrtRatioAtTick(params.tickLower),
                                          _slot0.sqrtPriceX96,
                                          params.liquidityDelta
                                      );
                                      liquidity = LiquidityMath.addDelta(liquidityBefore, params.liquidityDelta);
                                  } else {
                                      // current tick is above the passed range; liquidity can only become in range by crossing from right to
                                      // left, when we'll need _more_ token1 (it's becoming more valuable) so user must provide it
                                      amount1 = SqrtPriceMath.getAmount1Delta(
                                          TickMath.getSqrtRatioAtTick(params.tickLower),
                                          TickMath.getSqrtRatioAtTick(params.tickUpper),
                                          params.liquidityDelta
                                      );
                                  }
                              }
                          }
                          /// @dev Gets and updates a position with the given liquidity delta
                          /// @param owner the owner of the position
                          /// @param tickLower the lower tick of the position's tick range
                          /// @param tickUpper the upper tick of the position's tick range
                          /// @param tick the current tick, passed to avoid sloads
                          function _updatePosition(
                              address owner,
                              int24 tickLower,
                              int24 tickUpper,
                              int128 liquidityDelta,
                              int24 tick
                          ) private returns (Position.Info storage position) {
                              position = positions.get(owner, tickLower, tickUpper);
                              uint256 _feeGrowthGlobal0X128 = feeGrowthGlobal0X128; // SLOAD for gas optimization
                              uint256 _feeGrowthGlobal1X128 = feeGrowthGlobal1X128; // SLOAD for gas optimization
                              // if we need to update the ticks, do it
                              bool flippedLower;
                              bool flippedUpper;
                              if (liquidityDelta != 0) {
                                  uint32 time = _blockTimestamp();
                                  (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) =
                                      observations.observeSingle(
                                          time,
                                          0,
                                          slot0.tick,
                                          slot0.observationIndex,
                                          liquidity,
                                          slot0.observationCardinality
                                      );
                                  flippedLower = ticks.update(
                                      tickLower,
                                      tick,
                                      liquidityDelta,
                                      _feeGrowthGlobal0X128,
                                      _feeGrowthGlobal1X128,
                                      secondsPerLiquidityCumulativeX128,
                                      tickCumulative,
                                      time,
                                      false,
                                      maxLiquidityPerTick
                                  );
                                  flippedUpper = ticks.update(
                                      tickUpper,
                                      tick,
                                      liquidityDelta,
                                      _feeGrowthGlobal0X128,
                                      _feeGrowthGlobal1X128,
                                      secondsPerLiquidityCumulativeX128,
                                      tickCumulative,
                                      time,
                                      true,
                                      maxLiquidityPerTick
                                  );
                                  if (flippedLower) {
                                      tickBitmap.flipTick(tickLower, tickSpacing);
                                  }
                                  if (flippedUpper) {
                                      tickBitmap.flipTick(tickUpper, tickSpacing);
                                  }
                              }
                              (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) =
                                  ticks.getFeeGrowthInside(tickLower, tickUpper, tick, _feeGrowthGlobal0X128, _feeGrowthGlobal1X128);
                              position.update(liquidityDelta, feeGrowthInside0X128, feeGrowthInside1X128);
                              // clear any tick data that is no longer needed
                              if (liquidityDelta < 0) {
                                  if (flippedLower) {
                                      ticks.clear(tickLower);
                                  }
                                  if (flippedUpper) {
                                      ticks.clear(tickUpper);
                                  }
                              }
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          /// @dev noDelegateCall is applied indirectly via _modifyPosition
                          function mint(
                              address recipient,
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount,
                              bytes calldata data
                          ) external override lock returns (uint256 amount0, uint256 amount1) {
                              require(amount > 0);
                              (, int256 amount0Int, int256 amount1Int) =
                                  _modifyPosition(
                                      ModifyPositionParams({
                                          owner: recipient,
                                          tickLower: tickLower,
                                          tickUpper: tickUpper,
                                          liquidityDelta: int256(amount).toInt128()
                                      })
                                  );
                              amount0 = uint256(amount0Int);
                              amount1 = uint256(amount1Int);
                              uint256 balance0Before;
                              uint256 balance1Before;
                              if (amount0 > 0) balance0Before = balance0();
                              if (amount1 > 0) balance1Before = balance1();
                              IUniswapV3MintCallback(msg.sender).uniswapV3MintCallback(amount0, amount1, data);
                              if (amount0 > 0) require(balance0Before.add(amount0) <= balance0(), 'M0');
                              if (amount1 > 0) require(balance1Before.add(amount1) <= balance1(), 'M1');
                              emit Mint(msg.sender, recipient, tickLower, tickUpper, amount, amount0, amount1);
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          function collect(
                              address recipient,
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount0Requested,
                              uint128 amount1Requested
                          ) external override lock returns (uint128 amount0, uint128 amount1) {
                              // we don't need to checkTicks here, because invalid positions will never have non-zero tokensOwed{0,1}
                              Position.Info storage position = positions.get(msg.sender, tickLower, tickUpper);
                              amount0 = amount0Requested > position.tokensOwed0 ? position.tokensOwed0 : amount0Requested;
                              amount1 = amount1Requested > position.tokensOwed1 ? position.tokensOwed1 : amount1Requested;
                              if (amount0 > 0) {
                                  position.tokensOwed0 -= amount0;
                                  TransferHelper.safeTransfer(token0, recipient, amount0);
                              }
                              if (amount1 > 0) {
                                  position.tokensOwed1 -= amount1;
                                  TransferHelper.safeTransfer(token1, recipient, amount1);
                              }
                              emit Collect(msg.sender, recipient, tickLower, tickUpper, amount0, amount1);
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          /// @dev noDelegateCall is applied indirectly via _modifyPosition
                          function burn(
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount
                          ) external override lock returns (uint256 amount0, uint256 amount1) {
                              (Position.Info storage position, int256 amount0Int, int256 amount1Int) =
                                  _modifyPosition(
                                      ModifyPositionParams({
                                          owner: msg.sender,
                                          tickLower: tickLower,
                                          tickUpper: tickUpper,
                                          liquidityDelta: -int256(amount).toInt128()
                                      })
                                  );
                              amount0 = uint256(-amount0Int);
                              amount1 = uint256(-amount1Int);
                              if (amount0 > 0 || amount1 > 0) {
                                  (position.tokensOwed0, position.tokensOwed1) = (
                                      position.tokensOwed0 + uint128(amount0),
                                      position.tokensOwed1 + uint128(amount1)
                                  );
                              }
                              emit Burn(msg.sender, tickLower, tickUpper, amount, amount0, amount1);
                          }
                          struct SwapCache {
                              // the protocol fee for the input token
                              uint8 feeProtocol;
                              // liquidity at the beginning of the swap
                              uint128 liquidityStart;
                              // the timestamp of the current block
                              uint32 blockTimestamp;
                              // the current value of the tick accumulator, computed only if we cross an initialized tick
                              int56 tickCumulative;
                              // the current value of seconds per liquidity accumulator, computed only if we cross an initialized tick
                              uint160 secondsPerLiquidityCumulativeX128;
                              // whether we've computed and cached the above two accumulators
                              bool computedLatestObservation;
                          }
                          // the top level state of the swap, the results of which are recorded in storage at the end
                          struct SwapState {
                              // the amount remaining to be swapped in/out of the input/output asset
                              int256 amountSpecifiedRemaining;
                              // the amount already swapped out/in of the output/input asset
                              int256 amountCalculated;
                              // current sqrt(price)
                              uint160 sqrtPriceX96;
                              // the tick associated with the current price
                              int24 tick;
                              // the global fee growth of the input token
                              uint256 feeGrowthGlobalX128;
                              // amount of input token paid as protocol fee
                              uint128 protocolFee;
                              // the current liquidity in range
                              uint128 liquidity;
                          }
                          struct StepComputations {
                              // the price at the beginning of the step
                              uint160 sqrtPriceStartX96;
                              // the next tick to swap to from the current tick in the swap direction
                              int24 tickNext;
                              // whether tickNext is initialized or not
                              bool initialized;
                              // sqrt(price) for the next tick (1/0)
                              uint160 sqrtPriceNextX96;
                              // how much is being swapped in in this step
                              uint256 amountIn;
                              // how much is being swapped out
                              uint256 amountOut;
                              // how much fee is being paid in
                              uint256 feeAmount;
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          function swap(
                              address recipient,
                              bool zeroForOne,
                              int256 amountSpecified,
                              uint160 sqrtPriceLimitX96,
                              bytes calldata data
                          ) external override noDelegateCall returns (int256 amount0, int256 amount1) {
                              require(amountSpecified != 0, 'AS');
                              Slot0 memory slot0Start = slot0;
                              require(slot0Start.unlocked, 'LOK');
                              require(
                                  zeroForOne
                                      ? sqrtPriceLimitX96 < slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 > TickMath.MIN_SQRT_RATIO
                                      : sqrtPriceLimitX96 > slot0Start.sqrtPriceX96 && sqrtPriceLimitX96 < TickMath.MAX_SQRT_RATIO,
                                  'SPL'
                              );
                              slot0.unlocked = false;
                              SwapCache memory cache =
                                  SwapCache({
                                      liquidityStart: liquidity,
                                      blockTimestamp: _blockTimestamp(),
                                      feeProtocol: zeroForOne ? (slot0Start.feeProtocol % 16) : (slot0Start.feeProtocol >> 4),
                                      secondsPerLiquidityCumulativeX128: 0,
                                      tickCumulative: 0,
                                      computedLatestObservation: false
                                  });
                              bool exactInput = amountSpecified > 0;
                              SwapState memory state =
                                  SwapState({
                                      amountSpecifiedRemaining: amountSpecified,
                                      amountCalculated: 0,
                                      sqrtPriceX96: slot0Start.sqrtPriceX96,
                                      tick: slot0Start.tick,
                                      feeGrowthGlobalX128: zeroForOne ? feeGrowthGlobal0X128 : feeGrowthGlobal1X128,
                                      protocolFee: 0,
                                      liquidity: cache.liquidityStart
                                  });
                              // continue swapping as long as we haven't used the entire input/output and haven't reached the price limit
                              while (state.amountSpecifiedRemaining != 0 && state.sqrtPriceX96 != sqrtPriceLimitX96) {
                                  StepComputations memory step;
                                  step.sqrtPriceStartX96 = state.sqrtPriceX96;
                                  (step.tickNext, step.initialized) = tickBitmap.nextInitializedTickWithinOneWord(
                                      state.tick,
                                      tickSpacing,
                                      zeroForOne
                                  );
                                  // ensure that we do not overshoot the min/max tick, as the tick bitmap is not aware of these bounds
                                  if (step.tickNext < TickMath.MIN_TICK) {
                                      step.tickNext = TickMath.MIN_TICK;
                                  } else if (step.tickNext > TickMath.MAX_TICK) {
                                      step.tickNext = TickMath.MAX_TICK;
                                  }
                                  // get the price for the next tick
                                  step.sqrtPriceNextX96 = TickMath.getSqrtRatioAtTick(step.tickNext);
                                  // compute values to swap to the target tick, price limit, or point where input/output amount is exhausted
                                  (state.sqrtPriceX96, step.amountIn, step.amountOut, step.feeAmount) = SwapMath.computeSwapStep(
                                      state.sqrtPriceX96,
                                      (zeroForOne ? step.sqrtPriceNextX96 < sqrtPriceLimitX96 : step.sqrtPriceNextX96 > sqrtPriceLimitX96)
                                          ? sqrtPriceLimitX96
                                          : step.sqrtPriceNextX96,
                                      state.liquidity,
                                      state.amountSpecifiedRemaining,
                                      fee
                                  );
                                  if (exactInput) {
                                      state.amountSpecifiedRemaining -= (step.amountIn + step.feeAmount).toInt256();
                                      state.amountCalculated = state.amountCalculated.sub(step.amountOut.toInt256());
                                  } else {
                                      state.amountSpecifiedRemaining += step.amountOut.toInt256();
                                      state.amountCalculated = state.amountCalculated.add((step.amountIn + step.feeAmount).toInt256());
                                  }
                                  // if the protocol fee is on, calculate how much is owed, decrement feeAmount, and increment protocolFee
                                  if (cache.feeProtocol > 0) {
                                      uint256 delta = step.feeAmount / cache.feeProtocol;
                                      step.feeAmount -= delta;
                                      state.protocolFee += uint128(delta);
                                  }
                                  // update global fee tracker
                                  if (state.liquidity > 0)
                                      state.feeGrowthGlobalX128 += FullMath.mulDiv(step.feeAmount, FixedPoint128.Q128, state.liquidity);
                                  // shift tick if we reached the next price
                                  if (state.sqrtPriceX96 == step.sqrtPriceNextX96) {
                                      // if the tick is initialized, run the tick transition
                                      if (step.initialized) {
                                          // check for the placeholder value, which we replace with the actual value the first time the swap
                                          // crosses an initialized tick
                                          if (!cache.computedLatestObservation) {
                                              (cache.tickCumulative, cache.secondsPerLiquidityCumulativeX128) = observations.observeSingle(
                                                  cache.blockTimestamp,
                                                  0,
                                                  slot0Start.tick,
                                                  slot0Start.observationIndex,
                                                  cache.liquidityStart,
                                                  slot0Start.observationCardinality
                                              );
                                              cache.computedLatestObservation = true;
                                          }
                                          int128 liquidityNet =
                                              ticks.cross(
                                                  step.tickNext,
                                                  (zeroForOne ? state.feeGrowthGlobalX128 : feeGrowthGlobal0X128),
                                                  (zeroForOne ? feeGrowthGlobal1X128 : state.feeGrowthGlobalX128),
                                                  cache.secondsPerLiquidityCumulativeX128,
                                                  cache.tickCumulative,
                                                  cache.blockTimestamp
                                              );
                                          // if we're moving leftward, we interpret liquidityNet as the opposite sign
                                          // safe because liquidityNet cannot be type(int128).min
                                          if (zeroForOne) liquidityNet = -liquidityNet;
                                          state.liquidity = LiquidityMath.addDelta(state.liquidity, liquidityNet);
                                      }
                                      state.tick = zeroForOne ? step.tickNext - 1 : step.tickNext;
                                  } else if (state.sqrtPriceX96 != step.sqrtPriceStartX96) {
                                      // recompute unless we're on a lower tick boundary (i.e. already transitioned ticks), and haven't moved
                                      state.tick = TickMath.getTickAtSqrtRatio(state.sqrtPriceX96);
                                  }
                              }
                              // update tick and write an oracle entry if the tick change
                              if (state.tick != slot0Start.tick) {
                                  (uint16 observationIndex, uint16 observationCardinality) =
                                      observations.write(
                                          slot0Start.observationIndex,
                                          cache.blockTimestamp,
                                          slot0Start.tick,
                                          cache.liquidityStart,
                                          slot0Start.observationCardinality,
                                          slot0Start.observationCardinalityNext
                                      );
                                  (slot0.sqrtPriceX96, slot0.tick, slot0.observationIndex, slot0.observationCardinality) = (
                                      state.sqrtPriceX96,
                                      state.tick,
                                      observationIndex,
                                      observationCardinality
                                  );
                              } else {
                                  // otherwise just update the price
                                  slot0.sqrtPriceX96 = state.sqrtPriceX96;
                              }
                              // update liquidity if it changed
                              if (cache.liquidityStart != state.liquidity) liquidity = state.liquidity;
                              // update fee growth global and, if necessary, protocol fees
                              // overflow is acceptable, protocol has to withdraw before it hits type(uint128).max fees
                              if (zeroForOne) {
                                  feeGrowthGlobal0X128 = state.feeGrowthGlobalX128;
                                  if (state.protocolFee > 0) protocolFees.token0 += state.protocolFee;
                              } else {
                                  feeGrowthGlobal1X128 = state.feeGrowthGlobalX128;
                                  if (state.protocolFee > 0) protocolFees.token1 += state.protocolFee;
                              }
                              (amount0, amount1) = zeroForOne == exactInput
                                  ? (amountSpecified - state.amountSpecifiedRemaining, state.amountCalculated)
                                  : (state.amountCalculated, amountSpecified - state.amountSpecifiedRemaining);
                              // do the transfers and collect payment
                              if (zeroForOne) {
                                  if (amount1 < 0) TransferHelper.safeTransfer(token1, recipient, uint256(-amount1));
                                  uint256 balance0Before = balance0();
                                  IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
                                  require(balance0Before.add(uint256(amount0)) <= balance0(), 'IIA');
                              } else {
                                  if (amount0 < 0) TransferHelper.safeTransfer(token0, recipient, uint256(-amount0));
                                  uint256 balance1Before = balance1();
                                  IUniswapV3SwapCallback(msg.sender).uniswapV3SwapCallback(amount0, amount1, data);
                                  require(balance1Before.add(uint256(amount1)) <= balance1(), 'IIA');
                              }
                              emit Swap(msg.sender, recipient, amount0, amount1, state.sqrtPriceX96, state.liquidity, state.tick);
                              slot0.unlocked = true;
                          }
                          /// @inheritdoc IUniswapV3PoolActions
                          function flash(
                              address recipient,
                              uint256 amount0,
                              uint256 amount1,
                              bytes calldata data
                          ) external override lock noDelegateCall {
                              uint128 _liquidity = liquidity;
                              require(_liquidity > 0, 'L');
                              uint256 fee0 = FullMath.mulDivRoundingUp(amount0, fee, 1e6);
                              uint256 fee1 = FullMath.mulDivRoundingUp(amount1, fee, 1e6);
                              uint256 balance0Before = balance0();
                              uint256 balance1Before = balance1();
                              if (amount0 > 0) TransferHelper.safeTransfer(token0, recipient, amount0);
                              if (amount1 > 0) TransferHelper.safeTransfer(token1, recipient, amount1);
                              IUniswapV3FlashCallback(msg.sender).uniswapV3FlashCallback(fee0, fee1, data);
                              uint256 balance0After = balance0();
                              uint256 balance1After = balance1();
                              require(balance0Before.add(fee0) <= balance0After, 'F0');
                              require(balance1Before.add(fee1) <= balance1After, 'F1');
                              // sub is safe because we know balanceAfter is gt balanceBefore by at least fee
                              uint256 paid0 = balance0After - balance0Before;
                              uint256 paid1 = balance1After - balance1Before;
                              if (paid0 > 0) {
                                  uint8 feeProtocol0 = slot0.feeProtocol % 16;
                                  uint256 fees0 = feeProtocol0 == 0 ? 0 : paid0 / feeProtocol0;
                                  if (uint128(fees0) > 0) protocolFees.token0 += uint128(fees0);
                                  feeGrowthGlobal0X128 += FullMath.mulDiv(paid0 - fees0, FixedPoint128.Q128, _liquidity);
                              }
                              if (paid1 > 0) {
                                  uint8 feeProtocol1 = slot0.feeProtocol >> 4;
                                  uint256 fees1 = feeProtocol1 == 0 ? 0 : paid1 / feeProtocol1;
                                  if (uint128(fees1) > 0) protocolFees.token1 += uint128(fees1);
                                  feeGrowthGlobal1X128 += FullMath.mulDiv(paid1 - fees1, FixedPoint128.Q128, _liquidity);
                              }
                              emit Flash(msg.sender, recipient, amount0, amount1, paid0, paid1);
                          }
                          /// @inheritdoc IUniswapV3PoolOwnerActions
                          function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external override lock onlyFactoryOwner {
                              require(
                                  (feeProtocol0 == 0 || (feeProtocol0 >= 4 && feeProtocol0 <= 10)) &&
                                      (feeProtocol1 == 0 || (feeProtocol1 >= 4 && feeProtocol1 <= 10))
                              );
                              uint8 feeProtocolOld = slot0.feeProtocol;
                              slot0.feeProtocol = feeProtocol0 + (feeProtocol1 << 4);
                              emit SetFeeProtocol(feeProtocolOld % 16, feeProtocolOld >> 4, feeProtocol0, feeProtocol1);
                          }
                          /// @inheritdoc IUniswapV3PoolOwnerActions
                          function collectProtocol(
                              address recipient,
                              uint128 amount0Requested,
                              uint128 amount1Requested
                          ) external override lock onlyFactoryOwner returns (uint128 amount0, uint128 amount1) {
                              amount0 = amount0Requested > protocolFees.token0 ? protocolFees.token0 : amount0Requested;
                              amount1 = amount1Requested > protocolFees.token1 ? protocolFees.token1 : amount1Requested;
                              if (amount0 > 0) {
                                  if (amount0 == protocolFees.token0) amount0--; // ensure that the slot is not cleared, for gas savings
                                  protocolFees.token0 -= amount0;
                                  TransferHelper.safeTransfer(token0, recipient, amount0);
                              }
                              if (amount1 > 0) {
                                  if (amount1 == protocolFees.token1) amount1--; // ensure that the slot is not cleared, for gas savings
                                  protocolFees.token1 -= amount1;
                                  TransferHelper.safeTransfer(token1, recipient, amount1);
                              }
                              emit CollectProtocol(msg.sender, recipient, amount0, amount1);
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      import './pool/IUniswapV3PoolImmutables.sol';
                      import './pool/IUniswapV3PoolState.sol';
                      import './pool/IUniswapV3PoolDerivedState.sol';
                      import './pool/IUniswapV3PoolActions.sol';
                      import './pool/IUniswapV3PoolOwnerActions.sol';
                      import './pool/IUniswapV3PoolEvents.sol';
                      /// @title The interface for a Uniswap V3 Pool
                      /// @notice A Uniswap pool facilitates swapping and automated market making between any two assets that strictly conform
                      /// to the ERC20 specification
                      /// @dev The pool interface is broken up into many smaller pieces
                      interface IUniswapV3Pool is
                          IUniswapV3PoolImmutables,
                          IUniswapV3PoolState,
                          IUniswapV3PoolDerivedState,
                          IUniswapV3PoolActions,
                          IUniswapV3PoolOwnerActions,
                          IUniswapV3PoolEvents
                      {
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity =0.7.6;
                      /// @title Prevents delegatecall to a contract
                      /// @notice Base contract that provides a modifier for preventing delegatecall to methods in a child contract
                      abstract contract NoDelegateCall {
                          /// @dev The original address of this contract
                          address private immutable original;
                          constructor() {
                              // Immutables are computed in the init code of the contract, and then inlined into the deployed bytecode.
                              // In other words, this variable won't change when it's checked at runtime.
                              original = address(this);
                          }
                          /// @dev Private method is used instead of inlining into modifier because modifiers are copied into each method,
                          ///     and the use of immutable means the address bytes are copied in every place the modifier is used.
                          function checkNotDelegateCall() private view {
                              require(address(this) == original);
                          }
                          /// @notice Prevents delegatecall into the modified method
                          modifier noDelegateCall() {
                              checkNotDelegateCall();
                              _;
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.7.0;
                      /// @title Optimized overflow and underflow safe math operations
                      /// @notice Contains methods for doing math operations that revert on overflow or underflow for minimal gas cost
                      library LowGasSafeMath {
                          /// @notice Returns x + y, reverts if sum overflows uint256
                          /// @param x The augend
                          /// @param y The addend
                          /// @return z The sum of x and y
                          function add(uint256 x, uint256 y) internal pure returns (uint256 z) {
                              require((z = x + y) >= x);
                          }
                          /// @notice Returns x - y, reverts if underflows
                          /// @param x The minuend
                          /// @param y The subtrahend
                          /// @return z The difference of x and y
                          function sub(uint256 x, uint256 y) internal pure returns (uint256 z) {
                              require((z = x - y) <= x);
                          }
                          /// @notice Returns x * y, reverts if overflows
                          /// @param x The multiplicand
                          /// @param y The multiplier
                          /// @return z The product of x and y
                          function mul(uint256 x, uint256 y) internal pure returns (uint256 z) {
                              require(x == 0 || (z = x * y) / x == y);
                          }
                          /// @notice Returns x + y, reverts if overflows or underflows
                          /// @param x The augend
                          /// @param y The addend
                          /// @return z The sum of x and y
                          function add(int256 x, int256 y) internal pure returns (int256 z) {
                              require((z = x + y) >= x == (y >= 0));
                          }
                          /// @notice Returns x - y, reverts if overflows or underflows
                          /// @param x The minuend
                          /// @param y The subtrahend
                          /// @return z The difference of x and y
                          function sub(int256 x, int256 y) internal pure returns (int256 z) {
                              require((z = x - y) <= x == (y >= 0));
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Safe casting methods
                      /// @notice Contains methods for safely casting between types
                      library SafeCast {
                          /// @notice Cast a uint256 to a uint160, revert on overflow
                          /// @param y The uint256 to be downcasted
                          /// @return z The downcasted integer, now type uint160
                          function toUint160(uint256 y) internal pure returns (uint160 z) {
                              require((z = uint160(y)) == y);
                          }
                          /// @notice Cast a int256 to a int128, revert on overflow or underflow
                          /// @param y The int256 to be downcasted
                          /// @return z The downcasted integer, now type int128
                          function toInt128(int256 y) internal pure returns (int128 z) {
                              require((z = int128(y)) == y);
                          }
                          /// @notice Cast a uint256 to a int256, revert on overflow
                          /// @param y The uint256 to be casted
                          /// @return z The casted integer, now type int256
                          function toInt256(uint256 y) internal pure returns (int256 z) {
                              require(y < 2**255);
                              z = int256(y);
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      import './LowGasSafeMath.sol';
                      import './SafeCast.sol';
                      import './TickMath.sol';
                      import './LiquidityMath.sol';
                      /// @title Tick
                      /// @notice Contains functions for managing tick processes and relevant calculations
                      library Tick {
                          using LowGasSafeMath for int256;
                          using SafeCast for int256;
                          // info stored for each initialized individual tick
                          struct Info {
                              // the total position liquidity that references this tick
                              uint128 liquidityGross;
                              // amount of net liquidity added (subtracted) when tick is crossed from left to right (right to left),
                              int128 liquidityNet;
                              // fee growth per unit of liquidity on the _other_ side of this tick (relative to the current tick)
                              // only has relative meaning, not absolute — the value depends on when the tick is initialized
                              uint256 feeGrowthOutside0X128;
                              uint256 feeGrowthOutside1X128;
                              // the cumulative tick value on the other side of the tick
                              int56 tickCumulativeOutside;
                              // the seconds per unit of liquidity on the _other_ side of this tick (relative to the current tick)
                              // only has relative meaning, not absolute — the value depends on when the tick is initialized
                              uint160 secondsPerLiquidityOutsideX128;
                              // the seconds spent on the other side of the tick (relative to the current tick)
                              // only has relative meaning, not absolute — the value depends on when the tick is initialized
                              uint32 secondsOutside;
                              // true iff the tick is initialized, i.e. the value is exactly equivalent to the expression liquidityGross != 0
                              // these 8 bits are set to prevent fresh sstores when crossing newly initialized ticks
                              bool initialized;
                          }
                          /// @notice Derives max liquidity per tick from given tick spacing
                          /// @dev Executed within the pool constructor
                          /// @param tickSpacing The amount of required tick separation, realized in multiples of `tickSpacing`
                          ///     e.g., a tickSpacing of 3 requires ticks to be initialized every 3rd tick i.e., ..., -6, -3, 0, 3, 6, ...
                          /// @return The max liquidity per tick
                          function tickSpacingToMaxLiquidityPerTick(int24 tickSpacing) internal pure returns (uint128) {
                              int24 minTick = (TickMath.MIN_TICK / tickSpacing) * tickSpacing;
                              int24 maxTick = (TickMath.MAX_TICK / tickSpacing) * tickSpacing;
                              uint24 numTicks = uint24((maxTick - minTick) / tickSpacing) + 1;
                              return type(uint128).max / numTicks;
                          }
                          /// @notice Retrieves fee growth data
                          /// @param self The mapping containing all tick information for initialized ticks
                          /// @param tickLower The lower tick boundary of the position
                          /// @param tickUpper The upper tick boundary of the position
                          /// @param tickCurrent The current tick
                          /// @param feeGrowthGlobal0X128 The all-time global fee growth, per unit of liquidity, in token0
                          /// @param feeGrowthGlobal1X128 The all-time global fee growth, per unit of liquidity, in token1
                          /// @return feeGrowthInside0X128 The all-time fee growth in token0, per unit of liquidity, inside the position's tick boundaries
                          /// @return feeGrowthInside1X128 The all-time fee growth in token1, per unit of liquidity, inside the position's tick boundaries
                          function getFeeGrowthInside(
                              mapping(int24 => Tick.Info) storage self,
                              int24 tickLower,
                              int24 tickUpper,
                              int24 tickCurrent,
                              uint256 feeGrowthGlobal0X128,
                              uint256 feeGrowthGlobal1X128
                          ) internal view returns (uint256 feeGrowthInside0X128, uint256 feeGrowthInside1X128) {
                              Info storage lower = self[tickLower];
                              Info storage upper = self[tickUpper];
                              // calculate fee growth below
                              uint256 feeGrowthBelow0X128;
                              uint256 feeGrowthBelow1X128;
                              if (tickCurrent >= tickLower) {
                                  feeGrowthBelow0X128 = lower.feeGrowthOutside0X128;
                                  feeGrowthBelow1X128 = lower.feeGrowthOutside1X128;
                              } else {
                                  feeGrowthBelow0X128 = feeGrowthGlobal0X128 - lower.feeGrowthOutside0X128;
                                  feeGrowthBelow1X128 = feeGrowthGlobal1X128 - lower.feeGrowthOutside1X128;
                              }
                              // calculate fee growth above
                              uint256 feeGrowthAbove0X128;
                              uint256 feeGrowthAbove1X128;
                              if (tickCurrent < tickUpper) {
                                  feeGrowthAbove0X128 = upper.feeGrowthOutside0X128;
                                  feeGrowthAbove1X128 = upper.feeGrowthOutside1X128;
                              } else {
                                  feeGrowthAbove0X128 = feeGrowthGlobal0X128 - upper.feeGrowthOutside0X128;
                                  feeGrowthAbove1X128 = feeGrowthGlobal1X128 - upper.feeGrowthOutside1X128;
                              }
                              feeGrowthInside0X128 = feeGrowthGlobal0X128 - feeGrowthBelow0X128 - feeGrowthAbove0X128;
                              feeGrowthInside1X128 = feeGrowthGlobal1X128 - feeGrowthBelow1X128 - feeGrowthAbove1X128;
                          }
                          /// @notice Updates a tick and returns true if the tick was flipped from initialized to uninitialized, or vice versa
                          /// @param self The mapping containing all tick information for initialized ticks
                          /// @param tick The tick that will be updated
                          /// @param tickCurrent The current tick
                          /// @param liquidityDelta A new amount of liquidity to be added (subtracted) when tick is crossed from left to right (right to left)
                          /// @param feeGrowthGlobal0X128 The all-time global fee growth, per unit of liquidity, in token0
                          /// @param feeGrowthGlobal1X128 The all-time global fee growth, per unit of liquidity, in token1
                          /// @param secondsPerLiquidityCumulativeX128 The all-time seconds per max(1, liquidity) of the pool
                          /// @param time The current block timestamp cast to a uint32
                          /// @param upper true for updating a position's upper tick, or false for updating a position's lower tick
                          /// @param maxLiquidity The maximum liquidity allocation for a single tick
                          /// @return flipped Whether the tick was flipped from initialized to uninitialized, or vice versa
                          function update(
                              mapping(int24 => Tick.Info) storage self,
                              int24 tick,
                              int24 tickCurrent,
                              int128 liquidityDelta,
                              uint256 feeGrowthGlobal0X128,
                              uint256 feeGrowthGlobal1X128,
                              uint160 secondsPerLiquidityCumulativeX128,
                              int56 tickCumulative,
                              uint32 time,
                              bool upper,
                              uint128 maxLiquidity
                          ) internal returns (bool flipped) {
                              Tick.Info storage info = self[tick];
                              uint128 liquidityGrossBefore = info.liquidityGross;
                              uint128 liquidityGrossAfter = LiquidityMath.addDelta(liquidityGrossBefore, liquidityDelta);
                              require(liquidityGrossAfter <= maxLiquidity, 'LO');
                              flipped = (liquidityGrossAfter == 0) != (liquidityGrossBefore == 0);
                              if (liquidityGrossBefore == 0) {
                                  // by convention, we assume that all growth before a tick was initialized happened _below_ the tick
                                  if (tick <= tickCurrent) {
                                      info.feeGrowthOutside0X128 = feeGrowthGlobal0X128;
                                      info.feeGrowthOutside1X128 = feeGrowthGlobal1X128;
                                      info.secondsPerLiquidityOutsideX128 = secondsPerLiquidityCumulativeX128;
                                      info.tickCumulativeOutside = tickCumulative;
                                      info.secondsOutside = time;
                                  }
                                  info.initialized = true;
                              }
                              info.liquidityGross = liquidityGrossAfter;
                              // when the lower (upper) tick is crossed left to right (right to left), liquidity must be added (removed)
                              info.liquidityNet = upper
                                  ? int256(info.liquidityNet).sub(liquidityDelta).toInt128()
                                  : int256(info.liquidityNet).add(liquidityDelta).toInt128();
                          }
                          /// @notice Clears tick data
                          /// @param self The mapping containing all initialized tick information for initialized ticks
                          /// @param tick The tick that will be cleared
                          function clear(mapping(int24 => Tick.Info) storage self, int24 tick) internal {
                              delete self[tick];
                          }
                          /// @notice Transitions to next tick as needed by price movement
                          /// @param self The mapping containing all tick information for initialized ticks
                          /// @param tick The destination tick of the transition
                          /// @param feeGrowthGlobal0X128 The all-time global fee growth, per unit of liquidity, in token0
                          /// @param feeGrowthGlobal1X128 The all-time global fee growth, per unit of liquidity, in token1
                          /// @param secondsPerLiquidityCumulativeX128 The current seconds per liquidity
                          /// @param time The current block.timestamp
                          /// @return liquidityNet The amount of liquidity added (subtracted) when tick is crossed from left to right (right to left)
                          function cross(
                              mapping(int24 => Tick.Info) storage self,
                              int24 tick,
                              uint256 feeGrowthGlobal0X128,
                              uint256 feeGrowthGlobal1X128,
                              uint160 secondsPerLiquidityCumulativeX128,
                              int56 tickCumulative,
                              uint32 time
                          ) internal returns (int128 liquidityNet) {
                              Tick.Info storage info = self[tick];
                              info.feeGrowthOutside0X128 = feeGrowthGlobal0X128 - info.feeGrowthOutside0X128;
                              info.feeGrowthOutside1X128 = feeGrowthGlobal1X128 - info.feeGrowthOutside1X128;
                              info.secondsPerLiquidityOutsideX128 = secondsPerLiquidityCumulativeX128 - info.secondsPerLiquidityOutsideX128;
                              info.tickCumulativeOutside = tickCumulative - info.tickCumulativeOutside;
                              info.secondsOutside = time - info.secondsOutside;
                              liquidityNet = info.liquidityNet;
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      import './BitMath.sol';
                      /// @title Packed tick initialized state library
                      /// @notice Stores a packed mapping of tick index to its initialized state
                      /// @dev The mapping uses int16 for keys since ticks are represented as int24 and there are 256 (2^8) values per word.
                      library TickBitmap {
                          /// @notice Computes the position in the mapping where the initialized bit for a tick lives
                          /// @param tick The tick for which to compute the position
                          /// @return wordPos The key in the mapping containing the word in which the bit is stored
                          /// @return bitPos The bit position in the word where the flag is stored
                          function position(int24 tick) private pure returns (int16 wordPos, uint8 bitPos) {
                              wordPos = int16(tick >> 8);
                              bitPos = uint8(tick % 256);
                          }
                          /// @notice Flips the initialized state for a given tick from false to true, or vice versa
                          /// @param self The mapping in which to flip the tick
                          /// @param tick The tick to flip
                          /// @param tickSpacing The spacing between usable ticks
                          function flipTick(
                              mapping(int16 => uint256) storage self,
                              int24 tick,
                              int24 tickSpacing
                          ) internal {
                              require(tick % tickSpacing == 0); // ensure that the tick is spaced
                              (int16 wordPos, uint8 bitPos) = position(tick / tickSpacing);
                              uint256 mask = 1 << bitPos;
                              self[wordPos] ^= mask;
                          }
                          /// @notice Returns the next initialized tick contained in the same word (or adjacent word) as the tick that is either
                          /// to the left (less than or equal to) or right (greater than) of the given tick
                          /// @param self The mapping in which to compute the next initialized tick
                          /// @param tick The starting tick
                          /// @param tickSpacing The spacing between usable ticks
                          /// @param lte Whether to search for the next initialized tick to the left (less than or equal to the starting tick)
                          /// @return next The next initialized or uninitialized tick up to 256 ticks away from the current tick
                          /// @return initialized Whether the next tick is initialized, as the function only searches within up to 256 ticks
                          function nextInitializedTickWithinOneWord(
                              mapping(int16 => uint256) storage self,
                              int24 tick,
                              int24 tickSpacing,
                              bool lte
                          ) internal view returns (int24 next, bool initialized) {
                              int24 compressed = tick / tickSpacing;
                              if (tick < 0 && tick % tickSpacing != 0) compressed--; // round towards negative infinity
                              if (lte) {
                                  (int16 wordPos, uint8 bitPos) = position(compressed);
                                  // all the 1s at or to the right of the current bitPos
                                  uint256 mask = (1 << bitPos) - 1 + (1 << bitPos);
                                  uint256 masked = self[wordPos] & mask;
                                  // if there are no initialized ticks to the right of or at the current tick, return rightmost in the word
                                  initialized = masked != 0;
                                  // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick
                                  next = initialized
                                      ? (compressed - int24(bitPos - BitMath.mostSignificantBit(masked))) * tickSpacing
                                      : (compressed - int24(bitPos)) * tickSpacing;
                              } else {
                                  // start from the word of the next tick, since the current tick state doesn't matter
                                  (int16 wordPos, uint8 bitPos) = position(compressed + 1);
                                  // all the 1s at or to the left of the bitPos
                                  uint256 mask = ~((1 << bitPos) - 1);
                                  uint256 masked = self[wordPos] & mask;
                                  // if there are no initialized ticks to the left of the current tick, return leftmost in the word
                                  initialized = masked != 0;
                                  // overflow/underflow is possible, but prevented externally by limiting both tickSpacing and tick
                                  next = initialized
                                      ? (compressed + 1 + int24(BitMath.leastSignificantBit(masked) - bitPos)) * tickSpacing
                                      : (compressed + 1 + int24(type(uint8).max - bitPos)) * tickSpacing;
                              }
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      import './FullMath.sol';
                      import './FixedPoint128.sol';
                      import './LiquidityMath.sol';
                      /// @title Position
                      /// @notice Positions represent an owner address' liquidity between a lower and upper tick boundary
                      /// @dev Positions store additional state for tracking fees owed to the position
                      library Position {
                          // info stored for each user's position
                          struct Info {
                              // the amount of liquidity owned by this position
                              uint128 liquidity;
                              // fee growth per unit of liquidity as of the last update to liquidity or fees owed
                              uint256 feeGrowthInside0LastX128;
                              uint256 feeGrowthInside1LastX128;
                              // the fees owed to the position owner in token0/token1
                              uint128 tokensOwed0;
                              uint128 tokensOwed1;
                          }
                          /// @notice Returns the Info struct of a position, given an owner and position boundaries
                          /// @param self The mapping containing all user positions
                          /// @param owner The address of the position owner
                          /// @param tickLower The lower tick boundary of the position
                          /// @param tickUpper The upper tick boundary of the position
                          /// @return position The position info struct of the given owners' position
                          function get(
                              mapping(bytes32 => Info) storage self,
                              address owner,
                              int24 tickLower,
                              int24 tickUpper
                          ) internal view returns (Position.Info storage position) {
                              position = self[keccak256(abi.encodePacked(owner, tickLower, tickUpper))];
                          }
                          /// @notice Credits accumulated fees to a user's position
                          /// @param self The individual position to update
                          /// @param liquidityDelta The change in pool liquidity as a result of the position update
                          /// @param feeGrowthInside0X128 The all-time fee growth in token0, per unit of liquidity, inside the position's tick boundaries
                          /// @param feeGrowthInside1X128 The all-time fee growth in token1, per unit of liquidity, inside the position's tick boundaries
                          function update(
                              Info storage self,
                              int128 liquidityDelta,
                              uint256 feeGrowthInside0X128,
                              uint256 feeGrowthInside1X128
                          ) internal {
                              Info memory _self = self;
                              uint128 liquidityNext;
                              if (liquidityDelta == 0) {
                                  require(_self.liquidity > 0, 'NP'); // disallow pokes for 0 liquidity positions
                                  liquidityNext = _self.liquidity;
                              } else {
                                  liquidityNext = LiquidityMath.addDelta(_self.liquidity, liquidityDelta);
                              }
                              // calculate accumulated fees
                              uint128 tokensOwed0 =
                                  uint128(
                                      FullMath.mulDiv(
                                          feeGrowthInside0X128 - _self.feeGrowthInside0LastX128,
                                          _self.liquidity,
                                          FixedPoint128.Q128
                                      )
                                  );
                              uint128 tokensOwed1 =
                                  uint128(
                                      FullMath.mulDiv(
                                          feeGrowthInside1X128 - _self.feeGrowthInside1LastX128,
                                          _self.liquidity,
                                          FixedPoint128.Q128
                                      )
                                  );
                              // update the position
                              if (liquidityDelta != 0) self.liquidity = liquidityNext;
                              self.feeGrowthInside0LastX128 = feeGrowthInside0X128;
                              self.feeGrowthInside1LastX128 = feeGrowthInside1X128;
                              if (tokensOwed0 > 0 || tokensOwed1 > 0) {
                                  // overflow is acceptable, have to withdraw before you hit type(uint128).max fees
                                  self.tokensOwed0 += tokensOwed0;
                                  self.tokensOwed1 += tokensOwed1;
                              }
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      /// @title Oracle
                      /// @notice Provides price and liquidity data useful for a wide variety of system designs
                      /// @dev Instances of stored oracle data, "observations", are collected in the oracle array
                      /// Every pool is initialized with an oracle array length of 1. Anyone can pay the SSTOREs to increase the
                      /// maximum length of the oracle array. New slots will be added when the array is fully populated.
                      /// Observations are overwritten when the full length of the oracle array is populated.
                      /// The most recent observation is available, independent of the length of the oracle array, by passing 0 to observe()
                      library Oracle {
                          struct Observation {
                              // the block timestamp of the observation
                              uint32 blockTimestamp;
                              // the tick accumulator, i.e. tick * time elapsed since the pool was first initialized
                              int56 tickCumulative;
                              // the seconds per liquidity, i.e. seconds elapsed / max(1, liquidity) since the pool was first initialized
                              uint160 secondsPerLiquidityCumulativeX128;
                              // whether or not the observation is initialized
                              bool initialized;
                          }
                          /// @notice Transforms a previous observation into a new observation, given the passage of time and the current tick and liquidity values
                          /// @dev blockTimestamp _must_ be chronologically equal to or greater than last.blockTimestamp, safe for 0 or 1 overflows
                          /// @param last The specified observation to be transformed
                          /// @param blockTimestamp The timestamp of the new observation
                          /// @param tick The active tick at the time of the new observation
                          /// @param liquidity The total in-range liquidity at the time of the new observation
                          /// @return Observation The newly populated observation
                          function transform(
                              Observation memory last,
                              uint32 blockTimestamp,
                              int24 tick,
                              uint128 liquidity
                          ) private pure returns (Observation memory) {
                              uint32 delta = blockTimestamp - last.blockTimestamp;
                              return
                                  Observation({
                                      blockTimestamp: blockTimestamp,
                                      tickCumulative: last.tickCumulative + int56(tick) * delta,
                                      secondsPerLiquidityCumulativeX128: last.secondsPerLiquidityCumulativeX128 +
                                          ((uint160(delta) << 128) / (liquidity > 0 ? liquidity : 1)),
                                      initialized: true
                                  });
                          }
                          /// @notice Initialize the oracle array by writing the first slot. Called once for the lifecycle of the observations array
                          /// @param self The stored oracle array
                          /// @param time The time of the oracle initialization, via block.timestamp truncated to uint32
                          /// @return cardinality The number of populated elements in the oracle array
                          /// @return cardinalityNext The new length of the oracle array, independent of population
                          function initialize(Observation[65535] storage self, uint32 time)
                              internal
                              returns (uint16 cardinality, uint16 cardinalityNext)
                          {
                              self[0] = Observation({
                                  blockTimestamp: time,
                                  tickCumulative: 0,
                                  secondsPerLiquidityCumulativeX128: 0,
                                  initialized: true
                              });
                              return (1, 1);
                          }
                          /// @notice Writes an oracle observation to the array
                          /// @dev Writable at most once per block. Index represents the most recently written element. cardinality and index must be tracked externally.
                          /// If the index is at the end of the allowable array length (according to cardinality), and the next cardinality
                          /// is greater than the current one, cardinality may be increased. This restriction is created to preserve ordering.
                          /// @param self The stored oracle array
                          /// @param index The index of the observation that was most recently written to the observations array
                          /// @param blockTimestamp The timestamp of the new observation
                          /// @param tick The active tick at the time of the new observation
                          /// @param liquidity The total in-range liquidity at the time of the new observation
                          /// @param cardinality The number of populated elements in the oracle array
                          /// @param cardinalityNext The new length of the oracle array, independent of population
                          /// @return indexUpdated The new index of the most recently written element in the oracle array
                          /// @return cardinalityUpdated The new cardinality of the oracle array
                          function write(
                              Observation[65535] storage self,
                              uint16 index,
                              uint32 blockTimestamp,
                              int24 tick,
                              uint128 liquidity,
                              uint16 cardinality,
                              uint16 cardinalityNext
                          ) internal returns (uint16 indexUpdated, uint16 cardinalityUpdated) {
                              Observation memory last = self[index];
                              // early return if we've already written an observation this block
                              if (last.blockTimestamp == blockTimestamp) return (index, cardinality);
                              // if the conditions are right, we can bump the cardinality
                              if (cardinalityNext > cardinality && index == (cardinality - 1)) {
                                  cardinalityUpdated = cardinalityNext;
                              } else {
                                  cardinalityUpdated = cardinality;
                              }
                              indexUpdated = (index + 1) % cardinalityUpdated;
                              self[indexUpdated] = transform(last, blockTimestamp, tick, liquidity);
                          }
                          /// @notice Prepares the oracle array to store up to `next` observations
                          /// @param self The stored oracle array
                          /// @param current The current next cardinality of the oracle array
                          /// @param next The proposed next cardinality which will be populated in the oracle array
                          /// @return next The next cardinality which will be populated in the oracle array
                          function grow(
                              Observation[65535] storage self,
                              uint16 current,
                              uint16 next
                          ) internal returns (uint16) {
                              require(current > 0, 'I');
                              // no-op if the passed next value isn't greater than the current next value
                              if (next <= current) return current;
                              // store in each slot to prevent fresh SSTOREs in swaps
                              // this data will not be used because the initialized boolean is still false
                              for (uint16 i = current; i < next; i++) self[i].blockTimestamp = 1;
                              return next;
                          }
                          /// @notice comparator for 32-bit timestamps
                          /// @dev safe for 0 or 1 overflows, a and b _must_ be chronologically before or equal to time
                          /// @param time A timestamp truncated to 32 bits
                          /// @param a A comparison timestamp from which to determine the relative position of `time`
                          /// @param b From which to determine the relative position of `time`
                          /// @return bool Whether `a` is chronologically <= `b`
                          function lte(
                              uint32 time,
                              uint32 a,
                              uint32 b
                          ) private pure returns (bool) {
                              // if there hasn't been overflow, no need to adjust
                              if (a <= time && b <= time) return a <= b;
                              uint256 aAdjusted = a > time ? a : a + 2**32;
                              uint256 bAdjusted = b > time ? b : b + 2**32;
                              return aAdjusted <= bAdjusted;
                          }
                          /// @notice Fetches the observations beforeOrAt and atOrAfter a target, i.e. where [beforeOrAt, atOrAfter] is satisfied.
                          /// The result may be the same observation, or adjacent observations.
                          /// @dev The answer must be contained in the array, used when the target is located within the stored observation
                          /// boundaries: older than the most recent observation and younger, or the same age as, the oldest observation
                          /// @param self The stored oracle array
                          /// @param time The current block.timestamp
                          /// @param target The timestamp at which the reserved observation should be for
                          /// @param index The index of the observation that was most recently written to the observations array
                          /// @param cardinality The number of populated elements in the oracle array
                          /// @return beforeOrAt The observation recorded before, or at, the target
                          /// @return atOrAfter The observation recorded at, or after, the target
                          function binarySearch(
                              Observation[65535] storage self,
                              uint32 time,
                              uint32 target,
                              uint16 index,
                              uint16 cardinality
                          ) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
                              uint256 l = (index + 1) % cardinality; // oldest observation
                              uint256 r = l + cardinality - 1; // newest observation
                              uint256 i;
                              while (true) {
                                  i = (l + r) / 2;
                                  beforeOrAt = self[i % cardinality];
                                  // we've landed on an uninitialized tick, keep searching higher (more recently)
                                  if (!beforeOrAt.initialized) {
                                      l = i + 1;
                                      continue;
                                  }
                                  atOrAfter = self[(i + 1) % cardinality];
                                  bool targetAtOrAfter = lte(time, beforeOrAt.blockTimestamp, target);
                                  // check if we've found the answer!
                                  if (targetAtOrAfter && lte(time, target, atOrAfter.blockTimestamp)) break;
                                  if (!targetAtOrAfter) r = i - 1;
                                  else l = i + 1;
                              }
                          }
                          /// @notice Fetches the observations beforeOrAt and atOrAfter a given target, i.e. where [beforeOrAt, atOrAfter] is satisfied
                          /// @dev Assumes there is at least 1 initialized observation.
                          /// Used by observeSingle() to compute the counterfactual accumulator values as of a given block timestamp.
                          /// @param self The stored oracle array
                          /// @param time The current block.timestamp
                          /// @param target The timestamp at which the reserved observation should be for
                          /// @param tick The active tick at the time of the returned or simulated observation
                          /// @param index The index of the observation that was most recently written to the observations array
                          /// @param liquidity The total pool liquidity at the time of the call
                          /// @param cardinality The number of populated elements in the oracle array
                          /// @return beforeOrAt The observation which occurred at, or before, the given timestamp
                          /// @return atOrAfter The observation which occurred at, or after, the given timestamp
                          function getSurroundingObservations(
                              Observation[65535] storage self,
                              uint32 time,
                              uint32 target,
                              int24 tick,
                              uint16 index,
                              uint128 liquidity,
                              uint16 cardinality
                          ) private view returns (Observation memory beforeOrAt, Observation memory atOrAfter) {
                              // optimistically set before to the newest observation
                              beforeOrAt = self[index];
                              // if the target is chronologically at or after the newest observation, we can early return
                              if (lte(time, beforeOrAt.blockTimestamp, target)) {
                                  if (beforeOrAt.blockTimestamp == target) {
                                      // if newest observation equals target, we're in the same block, so we can ignore atOrAfter
                                      return (beforeOrAt, atOrAfter);
                                  } else {
                                      // otherwise, we need to transform
                                      return (beforeOrAt, transform(beforeOrAt, target, tick, liquidity));
                                  }
                              }
                              // now, set before to the oldest observation
                              beforeOrAt = self[(index + 1) % cardinality];
                              if (!beforeOrAt.initialized) beforeOrAt = self[0];
                              // ensure that the target is chronologically at or after the oldest observation
                              require(lte(time, beforeOrAt.blockTimestamp, target), 'OLD');
                              // if we've reached this point, we have to binary search
                              return binarySearch(self, time, target, index, cardinality);
                          }
                          /// @dev Reverts if an observation at or before the desired observation timestamp does not exist.
                          /// 0 may be passed as `secondsAgo' to return the current cumulative values.
                          /// If called with a timestamp falling between two observations, returns the counterfactual accumulator values
                          /// at exactly the timestamp between the two observations.
                          /// @param self The stored oracle array
                          /// @param time The current block timestamp
                          /// @param secondsAgo The amount of time to look back, in seconds, at which point to return an observation
                          /// @param tick The current tick
                          /// @param index The index of the observation that was most recently written to the observations array
                          /// @param liquidity The current in-range pool liquidity
                          /// @param cardinality The number of populated elements in the oracle array
                          /// @return tickCumulative The tick * time elapsed since the pool was first initialized, as of `secondsAgo`
                          /// @return secondsPerLiquidityCumulativeX128 The time elapsed / max(1, liquidity) since the pool was first initialized, as of `secondsAgo`
                          function observeSingle(
                              Observation[65535] storage self,
                              uint32 time,
                              uint32 secondsAgo,
                              int24 tick,
                              uint16 index,
                              uint128 liquidity,
                              uint16 cardinality
                          ) internal view returns (int56 tickCumulative, uint160 secondsPerLiquidityCumulativeX128) {
                              if (secondsAgo == 0) {
                                  Observation memory last = self[index];
                                  if (last.blockTimestamp != time) last = transform(last, time, tick, liquidity);
                                  return (last.tickCumulative, last.secondsPerLiquidityCumulativeX128);
                              }
                              uint32 target = time - secondsAgo;
                              (Observation memory beforeOrAt, Observation memory atOrAfter) =
                                  getSurroundingObservations(self, time, target, tick, index, liquidity, cardinality);
                              if (target == beforeOrAt.blockTimestamp) {
                                  // we're at the left boundary
                                  return (beforeOrAt.tickCumulative, beforeOrAt.secondsPerLiquidityCumulativeX128);
                              } else if (target == atOrAfter.blockTimestamp) {
                                  // we're at the right boundary
                                  return (atOrAfter.tickCumulative, atOrAfter.secondsPerLiquidityCumulativeX128);
                              } else {
                                  // we're in the middle
                                  uint32 observationTimeDelta = atOrAfter.blockTimestamp - beforeOrAt.blockTimestamp;
                                  uint32 targetDelta = target - beforeOrAt.blockTimestamp;
                                  return (
                                      beforeOrAt.tickCumulative +
                                          ((atOrAfter.tickCumulative - beforeOrAt.tickCumulative) / observationTimeDelta) *
                                          targetDelta,
                                      beforeOrAt.secondsPerLiquidityCumulativeX128 +
                                          uint160(
                                              (uint256(
                                                  atOrAfter.secondsPerLiquidityCumulativeX128 - beforeOrAt.secondsPerLiquidityCumulativeX128
                                              ) * targetDelta) / observationTimeDelta
                                          )
                                  );
                              }
                          }
                          /// @notice Returns the accumulator values as of each time seconds ago from the given time in the array of `secondsAgos`
                          /// @dev Reverts if `secondsAgos` > oldest observation
                          /// @param self The stored oracle array
                          /// @param time The current block.timestamp
                          /// @param secondsAgos Each amount of time to look back, in seconds, at which point to return an observation
                          /// @param tick The current tick
                          /// @param index The index of the observation that was most recently written to the observations array
                          /// @param liquidity The current in-range pool liquidity
                          /// @param cardinality The number of populated elements in the oracle array
                          /// @return tickCumulatives The tick * time elapsed since the pool was first initialized, as of each `secondsAgo`
                          /// @return secondsPerLiquidityCumulativeX128s The cumulative seconds / max(1, liquidity) since the pool was first initialized, as of each `secondsAgo`
                          function observe(
                              Observation[65535] storage self,
                              uint32 time,
                              uint32[] memory secondsAgos,
                              int24 tick,
                              uint16 index,
                              uint128 liquidity,
                              uint16 cardinality
                          ) internal view returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s) {
                              require(cardinality > 0, 'I');
                              tickCumulatives = new int56[](secondsAgos.length);
                              secondsPerLiquidityCumulativeX128s = new uint160[](secondsAgos.length);
                              for (uint256 i = 0; i < secondsAgos.length; i++) {
                                  (tickCumulatives[i], secondsPerLiquidityCumulativeX128s[i]) = observeSingle(
                                      self,
                                      time,
                                      secondsAgos[i],
                                      tick,
                                      index,
                                      liquidity,
                                      cardinality
                                  );
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      pragma solidity >=0.4.0;
                      /// @title Contains 512-bit math functions
                      /// @notice Facilitates multiplication and division that can have overflow of an intermediate value without any loss of precision
                      /// @dev Handles "phantom overflow" i.e., allows multiplication and division where an intermediate value overflows 256 bits
                      library FullMath {
                          /// @notice Calculates floor(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
                          /// @param a The multiplicand
                          /// @param b The multiplier
                          /// @param denominator The divisor
                          /// @return result The 256-bit result
                          /// @dev Credit to Remco Bloemen under MIT license https://xn--2-umb.com/21/muldiv
                          function mulDiv(
                              uint256 a,
                              uint256 b,
                              uint256 denominator
                          ) internal pure returns (uint256 result) {
                              // 512-bit multiply [prod1 prod0] = a * b
                              // Compute the product mod 2**256 and mod 2**256 - 1
                              // then use the Chinese Remainder Theorem to reconstruct
                              // the 512 bit result. The result is stored in two 256
                              // variables such that product = prod1 * 2**256 + prod0
                              uint256 prod0; // Least significant 256 bits of the product
                              uint256 prod1; // Most significant 256 bits of the product
                              assembly {
                                  let mm := mulmod(a, b, not(0))
                                  prod0 := mul(a, b)
                                  prod1 := sub(sub(mm, prod0), lt(mm, prod0))
                              }
                              // Handle non-overflow cases, 256 by 256 division
                              if (prod1 == 0) {
                                  require(denominator > 0);
                                  assembly {
                                      result := div(prod0, denominator)
                                  }
                                  return result;
                              }
                              // Make sure the result is less than 2**256.
                              // Also prevents denominator == 0
                              require(denominator > prod1);
                              ///////////////////////////////////////////////
                              // 512 by 256 division.
                              ///////////////////////////////////////////////
                              // Make division exact by subtracting the remainder from [prod1 prod0]
                              // Compute remainder using mulmod
                              uint256 remainder;
                              assembly {
                                  remainder := mulmod(a, b, denominator)
                              }
                              // Subtract 256 bit number from 512 bit number
                              assembly {
                                  prod1 := sub(prod1, gt(remainder, prod0))
                                  prod0 := sub(prod0, remainder)
                              }
                              // Factor powers of two out of denominator
                              // Compute largest power of two divisor of denominator.
                              // Always >= 1.
                              uint256 twos = -denominator & denominator;
                              // Divide denominator by power of two
                              assembly {
                                  denominator := div(denominator, twos)
                              }
                              // Divide [prod1 prod0] by the factors of two
                              assembly {
                                  prod0 := div(prod0, twos)
                              }
                              // Shift in bits from prod1 into prod0. For this we need
                              // to flip `twos` such that it is 2**256 / twos.
                              // If twos is zero, then it becomes one
                              assembly {
                                  twos := add(div(sub(0, twos), twos), 1)
                              }
                              prod0 |= prod1 * twos;
                              // Invert denominator mod 2**256
                              // Now that denominator is an odd number, it has an inverse
                              // modulo 2**256 such that denominator * inv = 1 mod 2**256.
                              // Compute the inverse by starting with a seed that is correct
                              // correct for four bits. That is, denominator * inv = 1 mod 2**4
                              uint256 inv = (3 * denominator) ^ 2;
                              // Now use Newton-Raphson iteration to improve the precision.
                              // Thanks to Hensel's lifting lemma, this also works in modular
                              // arithmetic, doubling the correct bits in each step.
                              inv *= 2 - denominator * inv; // inverse mod 2**8
                              inv *= 2 - denominator * inv; // inverse mod 2**16
                              inv *= 2 - denominator * inv; // inverse mod 2**32
                              inv *= 2 - denominator * inv; // inverse mod 2**64
                              inv *= 2 - denominator * inv; // inverse mod 2**128
                              inv *= 2 - denominator * inv; // inverse mod 2**256
                              // Because the division is now exact we can divide by multiplying
                              // with the modular inverse of denominator. This will give us the
                              // correct result modulo 2**256. Since the precoditions guarantee
                              // that the outcome is less than 2**256, this is the final result.
                              // We don't need to compute the high bits of the result and prod1
                              // is no longer required.
                              result = prod0 * inv;
                              return result;
                          }
                          /// @notice Calculates ceil(a×b÷denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
                          /// @param a The multiplicand
                          /// @param b The multiplier
                          /// @param denominator The divisor
                          /// @return result The 256-bit result
                          function mulDivRoundingUp(
                              uint256 a,
                              uint256 b,
                              uint256 denominator
                          ) internal pure returns (uint256 result) {
                              result = mulDiv(a, b, denominator);
                              if (mulmod(a, b, denominator) > 0) {
                                  require(result < type(uint256).max);
                                  result++;
                              }
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.4.0;
                      /// @title FixedPoint128
                      /// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)
                      library FixedPoint128 {
                          uint256 internal constant Q128 = 0x100000000000000000000000000000000;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.6.0;
                      import '../interfaces/IERC20Minimal.sol';
                      /// @title TransferHelper
                      /// @notice Contains helper methods for interacting with ERC20 tokens that do not consistently return true/false
                      library TransferHelper {
                          /// @notice Transfers tokens from msg.sender to a recipient
                          /// @dev Calls transfer on token contract, errors with TF if transfer fails
                          /// @param token The contract address of the token which will be transferred
                          /// @param to The recipient of the transfer
                          /// @param value The value of the transfer
                          function safeTransfer(
                              address token,
                              address to,
                              uint256 value
                          ) internal {
                              (bool success, bytes memory data) =
                                  token.call(abi.encodeWithSelector(IERC20Minimal.transfer.selector, to, value));
                              require(success && (data.length == 0 || abi.decode(data, (bool))), 'TF');
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Math library for computing sqrt prices from ticks and vice versa
                      /// @notice Computes sqrt price for ticks of size 1.0001, i.e. sqrt(1.0001^tick) as fixed point Q64.96 numbers. Supports
                      /// prices between 2**-128 and 2**128
                      library TickMath {
                          /// @dev The minimum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**-128
                          int24 internal constant MIN_TICK = -887272;
                          /// @dev The maximum tick that may be passed to #getSqrtRatioAtTick computed from log base 1.0001 of 2**128
                          int24 internal constant MAX_TICK = -MIN_TICK;
                          /// @dev The minimum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MIN_TICK)
                          uint160 internal constant MIN_SQRT_RATIO = 4295128739;
                          /// @dev The maximum value that can be returned from #getSqrtRatioAtTick. Equivalent to getSqrtRatioAtTick(MAX_TICK)
                          uint160 internal constant MAX_SQRT_RATIO = 1461446703485210103287273052203988822378723970342;
                          /// @notice Calculates sqrt(1.0001^tick) * 2^96
                          /// @dev Throws if |tick| > max tick
                          /// @param tick The input tick for the above formula
                          /// @return sqrtPriceX96 A Fixed point Q64.96 number representing the sqrt of the ratio of the two assets (token1/token0)
                          /// at the given tick
                          function getSqrtRatioAtTick(int24 tick) internal pure returns (uint160 sqrtPriceX96) {
                              uint256 absTick = tick < 0 ? uint256(-int256(tick)) : uint256(int256(tick));
                              require(absTick <= uint256(MAX_TICK), 'T');
                              uint256 ratio = absTick & 0x1 != 0 ? 0xfffcb933bd6fad37aa2d162d1a594001 : 0x100000000000000000000000000000000;
                              if (absTick & 0x2 != 0) ratio = (ratio * 0xfff97272373d413259a46990580e213a) >> 128;
                              if (absTick & 0x4 != 0) ratio = (ratio * 0xfff2e50f5f656932ef12357cf3c7fdcc) >> 128;
                              if (absTick & 0x8 != 0) ratio = (ratio * 0xffe5caca7e10e4e61c3624eaa0941cd0) >> 128;
                              if (absTick & 0x10 != 0) ratio = (ratio * 0xffcb9843d60f6159c9db58835c926644) >> 128;
                              if (absTick & 0x20 != 0) ratio = (ratio * 0xff973b41fa98c081472e6896dfb254c0) >> 128;
                              if (absTick & 0x40 != 0) ratio = (ratio * 0xff2ea16466c96a3843ec78b326b52861) >> 128;
                              if (absTick & 0x80 != 0) ratio = (ratio * 0xfe5dee046a99a2a811c461f1969c3053) >> 128;
                              if (absTick & 0x100 != 0) ratio = (ratio * 0xfcbe86c7900a88aedcffc83b479aa3a4) >> 128;
                              if (absTick & 0x200 != 0) ratio = (ratio * 0xf987a7253ac413176f2b074cf7815e54) >> 128;
                              if (absTick & 0x400 != 0) ratio = (ratio * 0xf3392b0822b70005940c7a398e4b70f3) >> 128;
                              if (absTick & 0x800 != 0) ratio = (ratio * 0xe7159475a2c29b7443b29c7fa6e889d9) >> 128;
                              if (absTick & 0x1000 != 0) ratio = (ratio * 0xd097f3bdfd2022b8845ad8f792aa5825) >> 128;
                              if (absTick & 0x2000 != 0) ratio = (ratio * 0xa9f746462d870fdf8a65dc1f90e061e5) >> 128;
                              if (absTick & 0x4000 != 0) ratio = (ratio * 0x70d869a156d2a1b890bb3df62baf32f7) >> 128;
                              if (absTick & 0x8000 != 0) ratio = (ratio * 0x31be135f97d08fd981231505542fcfa6) >> 128;
                              if (absTick & 0x10000 != 0) ratio = (ratio * 0x9aa508b5b7a84e1c677de54f3e99bc9) >> 128;
                              if (absTick & 0x20000 != 0) ratio = (ratio * 0x5d6af8dedb81196699c329225ee604) >> 128;
                              if (absTick & 0x40000 != 0) ratio = (ratio * 0x2216e584f5fa1ea926041bedfe98) >> 128;
                              if (absTick & 0x80000 != 0) ratio = (ratio * 0x48a170391f7dc42444e8fa2) >> 128;
                              if (tick > 0) ratio = type(uint256).max / ratio;
                              // this divides by 1<<32 rounding up to go from a Q128.128 to a Q128.96.
                              // we then downcast because we know the result always fits within 160 bits due to our tick input constraint
                              // we round up in the division so getTickAtSqrtRatio of the output price is always consistent
                              sqrtPriceX96 = uint160((ratio >> 32) + (ratio % (1 << 32) == 0 ? 0 : 1));
                          }
                          /// @notice Calculates the greatest tick value such that getRatioAtTick(tick) <= ratio
                          /// @dev Throws in case sqrtPriceX96 < MIN_SQRT_RATIO, as MIN_SQRT_RATIO is the lowest value getRatioAtTick may
                          /// ever return.
                          /// @param sqrtPriceX96 The sqrt ratio for which to compute the tick as a Q64.96
                          /// @return tick The greatest tick for which the ratio is less than or equal to the input ratio
                          function getTickAtSqrtRatio(uint160 sqrtPriceX96) internal pure returns (int24 tick) {
                              // second inequality must be < because the price can never reach the price at the max tick
                              require(sqrtPriceX96 >= MIN_SQRT_RATIO && sqrtPriceX96 < MAX_SQRT_RATIO, 'R');
                              uint256 ratio = uint256(sqrtPriceX96) << 32;
                              uint256 r = ratio;
                              uint256 msb = 0;
                              assembly {
                                  let f := shl(7, gt(r, 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(6, gt(r, 0xFFFFFFFFFFFFFFFF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(5, gt(r, 0xFFFFFFFF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(4, gt(r, 0xFFFF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(3, gt(r, 0xFF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(2, gt(r, 0xF))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := shl(1, gt(r, 0x3))
                                  msb := or(msb, f)
                                  r := shr(f, r)
                              }
                              assembly {
                                  let f := gt(r, 0x1)
                                  msb := or(msb, f)
                              }
                              if (msb >= 128) r = ratio >> (msb - 127);
                              else r = ratio << (127 - msb);
                              int256 log_2 = (int256(msb) - 128) << 64;
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(63, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(62, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(61, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(60, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(59, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(58, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(57, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(56, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(55, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(54, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(53, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(52, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(51, f))
                                  r := shr(f, r)
                              }
                              assembly {
                                  r := shr(127, mul(r, r))
                                  let f := shr(128, r)
                                  log_2 := or(log_2, shl(50, f))
                              }
                              int256 log_sqrt10001 = log_2 * 255738958999603826347141; // 128.128 number
                              int24 tickLow = int24((log_sqrt10001 - 3402992956809132418596140100660247210) >> 128);
                              int24 tickHi = int24((log_sqrt10001 + 291339464771989622907027621153398088495) >> 128);
                              tick = tickLow == tickHi ? tickLow : getSqrtRatioAtTick(tickHi) <= sqrtPriceX96 ? tickHi : tickLow;
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Math library for liquidity
                      library LiquidityMath {
                          /// @notice Add a signed liquidity delta to liquidity and revert if it overflows or underflows
                          /// @param x The liquidity before change
                          /// @param y The delta by which liquidity should be changed
                          /// @return z The liquidity delta
                          function addDelta(uint128 x, int128 y) internal pure returns (uint128 z) {
                              if (y < 0) {
                                  require((z = x - uint128(-y)) < x, 'LS');
                              } else {
                                  require((z = x + uint128(y)) >= x, 'LA');
                              }
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      import './LowGasSafeMath.sol';
                      import './SafeCast.sol';
                      import './FullMath.sol';
                      import './UnsafeMath.sol';
                      import './FixedPoint96.sol';
                      /// @title Functions based on Q64.96 sqrt price and liquidity
                      /// @notice Contains the math that uses square root of price as a Q64.96 and liquidity to compute deltas
                      library SqrtPriceMath {
                          using LowGasSafeMath for uint256;
                          using SafeCast for uint256;
                          /// @notice Gets the next sqrt price given a delta of token0
                          /// @dev Always rounds up, because in the exact output case (increasing price) we need to move the price at least
                          /// far enough to get the desired output amount, and in the exact input case (decreasing price) we need to move the
                          /// price less in order to not send too much output.
                          /// The most precise formula for this is liquidity * sqrtPX96 / (liquidity +- amount * sqrtPX96),
                          /// if this is impossible because of overflow, we calculate liquidity / (liquidity / sqrtPX96 +- amount).
                          /// @param sqrtPX96 The starting price, i.e. before accounting for the token0 delta
                          /// @param liquidity The amount of usable liquidity
                          /// @param amount How much of token0 to add or remove from virtual reserves
                          /// @param add Whether to add or remove the amount of token0
                          /// @return The price after adding or removing amount, depending on add
                          function getNextSqrtPriceFromAmount0RoundingUp(
                              uint160 sqrtPX96,
                              uint128 liquidity,
                              uint256 amount,
                              bool add
                          ) internal pure returns (uint160) {
                              // we short circuit amount == 0 because the result is otherwise not guaranteed to equal the input price
                              if (amount == 0) return sqrtPX96;
                              uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;
                              if (add) {
                                  uint256 product;
                                  if ((product = amount * sqrtPX96) / amount == sqrtPX96) {
                                      uint256 denominator = numerator1 + product;
                                      if (denominator >= numerator1)
                                          // always fits in 160 bits
                                          return uint160(FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator));
                                  }
                                  return uint160(UnsafeMath.divRoundingUp(numerator1, (numerator1 / sqrtPX96).add(amount)));
                              } else {
                                  uint256 product;
                                  // if the product overflows, we know the denominator underflows
                                  // in addition, we must check that the denominator does not underflow
                                  require((product = amount * sqrtPX96) / amount == sqrtPX96 && numerator1 > product);
                                  uint256 denominator = numerator1 - product;
                                  return FullMath.mulDivRoundingUp(numerator1, sqrtPX96, denominator).toUint160();
                              }
                          }
                          /// @notice Gets the next sqrt price given a delta of token1
                          /// @dev Always rounds down, because in the exact output case (decreasing price) we need to move the price at least
                          /// far enough to get the desired output amount, and in the exact input case (increasing price) we need to move the
                          /// price less in order to not send too much output.
                          /// The formula we compute is within <1 wei of the lossless version: sqrtPX96 +- amount / liquidity
                          /// @param sqrtPX96 The starting price, i.e., before accounting for the token1 delta
                          /// @param liquidity The amount of usable liquidity
                          /// @param amount How much of token1 to add, or remove, from virtual reserves
                          /// @param add Whether to add, or remove, the amount of token1
                          /// @return The price after adding or removing `amount`
                          function getNextSqrtPriceFromAmount1RoundingDown(
                              uint160 sqrtPX96,
                              uint128 liquidity,
                              uint256 amount,
                              bool add
                          ) internal pure returns (uint160) {
                              // if we're adding (subtracting), rounding down requires rounding the quotient down (up)
                              // in both cases, avoid a mulDiv for most inputs
                              if (add) {
                                  uint256 quotient =
                                      (
                                          amount <= type(uint160).max
                                              ? (amount << FixedPoint96.RESOLUTION) / liquidity
                                              : FullMath.mulDiv(amount, FixedPoint96.Q96, liquidity)
                                      );
                                  return uint256(sqrtPX96).add(quotient).toUint160();
                              } else {
                                  uint256 quotient =
                                      (
                                          amount <= type(uint160).max
                                              ? UnsafeMath.divRoundingUp(amount << FixedPoint96.RESOLUTION, liquidity)
                                              : FullMath.mulDivRoundingUp(amount, FixedPoint96.Q96, liquidity)
                                      );
                                  require(sqrtPX96 > quotient);
                                  // always fits 160 bits
                                  return uint160(sqrtPX96 - quotient);
                              }
                          }
                          /// @notice Gets the next sqrt price given an input amount of token0 or token1
                          /// @dev Throws if price or liquidity are 0, or if the next price is out of bounds
                          /// @param sqrtPX96 The starting price, i.e., before accounting for the input amount
                          /// @param liquidity The amount of usable liquidity
                          /// @param amountIn How much of token0, or token1, is being swapped in
                          /// @param zeroForOne Whether the amount in is token0 or token1
                          /// @return sqrtQX96 The price after adding the input amount to token0 or token1
                          function getNextSqrtPriceFromInput(
                              uint160 sqrtPX96,
                              uint128 liquidity,
                              uint256 amountIn,
                              bool zeroForOne
                          ) internal pure returns (uint160 sqrtQX96) {
                              require(sqrtPX96 > 0);
                              require(liquidity > 0);
                              // round to make sure that we don't pass the target price
                              return
                                  zeroForOne
                                      ? getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountIn, true)
                                      : getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountIn, true);
                          }
                          /// @notice Gets the next sqrt price given an output amount of token0 or token1
                          /// @dev Throws if price or liquidity are 0 or the next price is out of bounds
                          /// @param sqrtPX96 The starting price before accounting for the output amount
                          /// @param liquidity The amount of usable liquidity
                          /// @param amountOut How much of token0, or token1, is being swapped out
                          /// @param zeroForOne Whether the amount out is token0 or token1
                          /// @return sqrtQX96 The price after removing the output amount of token0 or token1
                          function getNextSqrtPriceFromOutput(
                              uint160 sqrtPX96,
                              uint128 liquidity,
                              uint256 amountOut,
                              bool zeroForOne
                          ) internal pure returns (uint160 sqrtQX96) {
                              require(sqrtPX96 > 0);
                              require(liquidity > 0);
                              // round to make sure that we pass the target price
                              return
                                  zeroForOne
                                      ? getNextSqrtPriceFromAmount1RoundingDown(sqrtPX96, liquidity, amountOut, false)
                                      : getNextSqrtPriceFromAmount0RoundingUp(sqrtPX96, liquidity, amountOut, false);
                          }
                          /// @notice Gets the amount0 delta between two prices
                          /// @dev Calculates liquidity / sqrt(lower) - liquidity / sqrt(upper),
                          /// i.e. liquidity * (sqrt(upper) - sqrt(lower)) / (sqrt(upper) * sqrt(lower))
                          /// @param sqrtRatioAX96 A sqrt price
                          /// @param sqrtRatioBX96 Another sqrt price
                          /// @param liquidity The amount of usable liquidity
                          /// @param roundUp Whether to round the amount up or down
                          /// @return amount0 Amount of token0 required to cover a position of size liquidity between the two passed prices
                          function getAmount0Delta(
                              uint160 sqrtRatioAX96,
                              uint160 sqrtRatioBX96,
                              uint128 liquidity,
                              bool roundUp
                          ) internal pure returns (uint256 amount0) {
                              if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
                              uint256 numerator1 = uint256(liquidity) << FixedPoint96.RESOLUTION;
                              uint256 numerator2 = sqrtRatioBX96 - sqrtRatioAX96;
                              require(sqrtRatioAX96 > 0);
                              return
                                  roundUp
                                      ? UnsafeMath.divRoundingUp(
                                          FullMath.mulDivRoundingUp(numerator1, numerator2, sqrtRatioBX96),
                                          sqrtRatioAX96
                                      )
                                      : FullMath.mulDiv(numerator1, numerator2, sqrtRatioBX96) / sqrtRatioAX96;
                          }
                          /// @notice Gets the amount1 delta between two prices
                          /// @dev Calculates liquidity * (sqrt(upper) - sqrt(lower))
                          /// @param sqrtRatioAX96 A sqrt price
                          /// @param sqrtRatioBX96 Another sqrt price
                          /// @param liquidity The amount of usable liquidity
                          /// @param roundUp Whether to round the amount up, or down
                          /// @return amount1 Amount of token1 required to cover a position of size liquidity between the two passed prices
                          function getAmount1Delta(
                              uint160 sqrtRatioAX96,
                              uint160 sqrtRatioBX96,
                              uint128 liquidity,
                              bool roundUp
                          ) internal pure returns (uint256 amount1) {
                              if (sqrtRatioAX96 > sqrtRatioBX96) (sqrtRatioAX96, sqrtRatioBX96) = (sqrtRatioBX96, sqrtRatioAX96);
                              return
                                  roundUp
                                      ? FullMath.mulDivRoundingUp(liquidity, sqrtRatioBX96 - sqrtRatioAX96, FixedPoint96.Q96)
                                      : FullMath.mulDiv(liquidity, sqrtRatioBX96 - sqrtRatioAX96, FixedPoint96.Q96);
                          }
                          /// @notice Helper that gets signed token0 delta
                          /// @param sqrtRatioAX96 A sqrt price
                          /// @param sqrtRatioBX96 Another sqrt price
                          /// @param liquidity The change in liquidity for which to compute the amount0 delta
                          /// @return amount0 Amount of token0 corresponding to the passed liquidityDelta between the two prices
                          function getAmount0Delta(
                              uint160 sqrtRatioAX96,
                              uint160 sqrtRatioBX96,
                              int128 liquidity
                          ) internal pure returns (int256 amount0) {
                              return
                                  liquidity < 0
                                      ? -getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, uint128(-liquidity), false).toInt256()
                                      : getAmount0Delta(sqrtRatioAX96, sqrtRatioBX96, uint128(liquidity), true).toInt256();
                          }
                          /// @notice Helper that gets signed token1 delta
                          /// @param sqrtRatioAX96 A sqrt price
                          /// @param sqrtRatioBX96 Another sqrt price
                          /// @param liquidity The change in liquidity for which to compute the amount1 delta
                          /// @return amount1 Amount of token1 corresponding to the passed liquidityDelta between the two prices
                          function getAmount1Delta(
                              uint160 sqrtRatioAX96,
                              uint160 sqrtRatioBX96,
                              int128 liquidity
                          ) internal pure returns (int256 amount1) {
                              return
                                  liquidity < 0
                                      ? -getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, uint128(-liquidity), false).toInt256()
                                      : getAmount1Delta(sqrtRatioAX96, sqrtRatioBX96, uint128(liquidity), true).toInt256();
                          }
                      }
                      // SPDX-License-Identifier: BUSL-1.1
                      pragma solidity >=0.5.0;
                      import './FullMath.sol';
                      import './SqrtPriceMath.sol';
                      /// @title Computes the result of a swap within ticks
                      /// @notice Contains methods for computing the result of a swap within a single tick price range, i.e., a single tick.
                      library SwapMath {
                          /// @notice Computes the result of swapping some amount in, or amount out, given the parameters of the swap
                          /// @dev The fee, plus the amount in, will never exceed the amount remaining if the swap's `amountSpecified` is positive
                          /// @param sqrtRatioCurrentX96 The current sqrt price of the pool
                          /// @param sqrtRatioTargetX96 The price that cannot be exceeded, from which the direction of the swap is inferred
                          /// @param liquidity The usable liquidity
                          /// @param amountRemaining How much input or output amount is remaining to be swapped in/out
                          /// @param feePips The fee taken from the input amount, expressed in hundredths of a bip
                          /// @return sqrtRatioNextX96 The price after swapping the amount in/out, not to exceed the price target
                          /// @return amountIn The amount to be swapped in, of either token0 or token1, based on the direction of the swap
                          /// @return amountOut The amount to be received, of either token0 or token1, based on the direction of the swap
                          /// @return feeAmount The amount of input that will be taken as a fee
                          function computeSwapStep(
                              uint160 sqrtRatioCurrentX96,
                              uint160 sqrtRatioTargetX96,
                              uint128 liquidity,
                              int256 amountRemaining,
                              uint24 feePips
                          )
                              internal
                              pure
                              returns (
                                  uint160 sqrtRatioNextX96,
                                  uint256 amountIn,
                                  uint256 amountOut,
                                  uint256 feeAmount
                              )
                          {
                              bool zeroForOne = sqrtRatioCurrentX96 >= sqrtRatioTargetX96;
                              bool exactIn = amountRemaining >= 0;
                              if (exactIn) {
                                  uint256 amountRemainingLessFee = FullMath.mulDiv(uint256(amountRemaining), 1e6 - feePips, 1e6);
                                  amountIn = zeroForOne
                                      ? SqrtPriceMath.getAmount0Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, true)
                                      : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, true);
                                  if (amountRemainingLessFee >= amountIn) sqrtRatioNextX96 = sqrtRatioTargetX96;
                                  else
                                      sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromInput(
                                          sqrtRatioCurrentX96,
                                          liquidity,
                                          amountRemainingLessFee,
                                          zeroForOne
                                      );
                              } else {
                                  amountOut = zeroForOne
                                      ? SqrtPriceMath.getAmount1Delta(sqrtRatioTargetX96, sqrtRatioCurrentX96, liquidity, false)
                                      : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioTargetX96, liquidity, false);
                                  if (uint256(-amountRemaining) >= amountOut) sqrtRatioNextX96 = sqrtRatioTargetX96;
                                  else
                                      sqrtRatioNextX96 = SqrtPriceMath.getNextSqrtPriceFromOutput(
                                          sqrtRatioCurrentX96,
                                          liquidity,
                                          uint256(-amountRemaining),
                                          zeroForOne
                                      );
                              }
                              bool max = sqrtRatioTargetX96 == sqrtRatioNextX96;
                              // get the input/output amounts
                              if (zeroForOne) {
                                  amountIn = max && exactIn
                                      ? amountIn
                                      : SqrtPriceMath.getAmount0Delta(sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, true);
                                  amountOut = max && !exactIn
                                      ? amountOut
                                      : SqrtPriceMath.getAmount1Delta(sqrtRatioNextX96, sqrtRatioCurrentX96, liquidity, false);
                              } else {
                                  amountIn = max && exactIn
                                      ? amountIn
                                      : SqrtPriceMath.getAmount1Delta(sqrtRatioCurrentX96, sqrtRatioNextX96, liquidity, true);
                                  amountOut = max && !exactIn
                                      ? amountOut
                                      : SqrtPriceMath.getAmount0Delta(sqrtRatioCurrentX96, sqrtRatioNextX96, liquidity, false);
                              }
                              // cap the output amount to not exceed the remaining output amount
                              if (!exactIn && amountOut > uint256(-amountRemaining)) {
                                  amountOut = uint256(-amountRemaining);
                              }
                              if (exactIn && sqrtRatioNextX96 != sqrtRatioTargetX96) {
                                  // we didn't reach the target, so take the remainder of the maximum input as fee
                                  feeAmount = uint256(amountRemaining) - amountIn;
                              } else {
                                  feeAmount = FullMath.mulDivRoundingUp(amountIn, feePips, 1e6 - feePips);
                              }
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title An interface for a contract that is capable of deploying Uniswap V3 Pools
                      /// @notice A contract that constructs a pool must implement this to pass arguments to the pool
                      /// @dev This is used to avoid having constructor arguments in the pool contract, which results in the init code hash
                      /// of the pool being constant allowing the CREATE2 address of the pool to be cheaply computed on-chain
                      interface IUniswapV3PoolDeployer {
                          /// @notice Get the parameters to be used in constructing the pool, set transiently during pool creation.
                          /// @dev Called by the pool constructor to fetch the parameters of the pool
                          /// Returns factory The factory address
                          /// Returns token0 The first token of the pool by address sort order
                          /// Returns token1 The second token of the pool by address sort order
                          /// Returns fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
                          /// Returns tickSpacing The minimum number of ticks between initialized ticks
                          function parameters()
                              external
                              view
                              returns (
                                  address factory,
                                  address token0,
                                  address token1,
                                  uint24 fee,
                                  int24 tickSpacing
                              );
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title The interface for the Uniswap V3 Factory
                      /// @notice The Uniswap V3 Factory facilitates creation of Uniswap V3 pools and control over the protocol fees
                      interface IUniswapV3Factory {
                          /// @notice Emitted when the owner of the factory is changed
                          /// @param oldOwner The owner before the owner was changed
                          /// @param newOwner The owner after the owner was changed
                          event OwnerChanged(address indexed oldOwner, address indexed newOwner);
                          /// @notice Emitted when a pool is created
                          /// @param token0 The first token of the pool by address sort order
                          /// @param token1 The second token of the pool by address sort order
                          /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
                          /// @param tickSpacing The minimum number of ticks between initialized ticks
                          /// @param pool The address of the created pool
                          event PoolCreated(
                              address indexed token0,
                              address indexed token1,
                              uint24 indexed fee,
                              int24 tickSpacing,
                              address pool
                          );
                          /// @notice Emitted when a new fee amount is enabled for pool creation via the factory
                          /// @param fee The enabled fee, denominated in hundredths of a bip
                          /// @param tickSpacing The minimum number of ticks between initialized ticks for pools created with the given fee
                          event FeeAmountEnabled(uint24 indexed fee, int24 indexed tickSpacing);
                          /// @notice Returns the current owner of the factory
                          /// @dev Can be changed by the current owner via setOwner
                          /// @return The address of the factory owner
                          function owner() external view returns (address);
                          /// @notice Returns the tick spacing for a given fee amount, if enabled, or 0 if not enabled
                          /// @dev A fee amount can never be removed, so this value should be hard coded or cached in the calling context
                          /// @param fee The enabled fee, denominated in hundredths of a bip. Returns 0 in case of unenabled fee
                          /// @return The tick spacing
                          function feeAmountTickSpacing(uint24 fee) external view returns (int24);
                          /// @notice Returns the pool address for a given pair of tokens and a fee, or address 0 if it does not exist
                          /// @dev tokenA and tokenB may be passed in either token0/token1 or token1/token0 order
                          /// @param tokenA The contract address of either token0 or token1
                          /// @param tokenB The contract address of the other token
                          /// @param fee The fee collected upon every swap in the pool, denominated in hundredths of a bip
                          /// @return pool The pool address
                          function getPool(
                              address tokenA,
                              address tokenB,
                              uint24 fee
                          ) external view returns (address pool);
                          /// @notice Creates a pool for the given two tokens and fee
                          /// @param tokenA One of the two tokens in the desired pool
                          /// @param tokenB The other of the two tokens in the desired pool
                          /// @param fee The desired fee for the pool
                          /// @dev tokenA and tokenB may be passed in either order: token0/token1 or token1/token0. tickSpacing is retrieved
                          /// from the fee. The call will revert if the pool already exists, the fee is invalid, or the token arguments
                          /// are invalid.
                          /// @return pool The address of the newly created pool
                          function createPool(
                              address tokenA,
                              address tokenB,
                              uint24 fee
                          ) external returns (address pool);
                          /// @notice Updates the owner of the factory
                          /// @dev Must be called by the current owner
                          /// @param _owner The new owner of the factory
                          function setOwner(address _owner) external;
                          /// @notice Enables a fee amount with the given tickSpacing
                          /// @dev Fee amounts may never be removed once enabled
                          /// @param fee The fee amount to enable, denominated in hundredths of a bip (i.e. 1e-6)
                          /// @param tickSpacing The spacing between ticks to be enforced for all pools created with the given fee amount
                          function enableFeeAmount(uint24 fee, int24 tickSpacing) external;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Minimal ERC20 interface for Uniswap
                      /// @notice Contains a subset of the full ERC20 interface that is used in Uniswap V3
                      interface IERC20Minimal {
                          /// @notice Returns the balance of a token
                          /// @param account The account for which to look up the number of tokens it has, i.e. its balance
                          /// @return The number of tokens held by the account
                          function balanceOf(address account) external view returns (uint256);
                          /// @notice Transfers the amount of token from the `msg.sender` to the recipient
                          /// @param recipient The account that will receive the amount transferred
                          /// @param amount The number of tokens to send from the sender to the recipient
                          /// @return Returns true for a successful transfer, false for an unsuccessful transfer
                          function transfer(address recipient, uint256 amount) external returns (bool);
                          /// @notice Returns the current allowance given to a spender by an owner
                          /// @param owner The account of the token owner
                          /// @param spender The account of the token spender
                          /// @return The current allowance granted by `owner` to `spender`
                          function allowance(address owner, address spender) external view returns (uint256);
                          /// @notice Sets the allowance of a spender from the `msg.sender` to the value `amount`
                          /// @param spender The account which will be allowed to spend a given amount of the owners tokens
                          /// @param amount The amount of tokens allowed to be used by `spender`
                          /// @return Returns true for a successful approval, false for unsuccessful
                          function approve(address spender, uint256 amount) external returns (bool);
                          /// @notice Transfers `amount` tokens from `sender` to `recipient` up to the allowance given to the `msg.sender`
                          /// @param sender The account from which the transfer will be initiated
                          /// @param recipient The recipient of the transfer
                          /// @param amount The amount of the transfer
                          /// @return Returns true for a successful transfer, false for unsuccessful
                          function transferFrom(
                              address sender,
                              address recipient,
                              uint256 amount
                          ) external returns (bool);
                          /// @notice Event emitted when tokens are transferred from one address to another, either via `#transfer` or `#transferFrom`.
                          /// @param from The account from which the tokens were sent, i.e. the balance decreased
                          /// @param to The account to which the tokens were sent, i.e. the balance increased
                          /// @param value The amount of tokens that were transferred
                          event Transfer(address indexed from, address indexed to, uint256 value);
                          /// @notice Event emitted when the approval amount for the spender of a given owner's tokens changes.
                          /// @param owner The account that approved spending of its tokens
                          /// @param spender The account for which the spending allowance was modified
                          /// @param value The new allowance from the owner to the spender
                          event Approval(address indexed owner, address indexed spender, uint256 value);
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Callback for IUniswapV3PoolActions#mint
                      /// @notice Any contract that calls IUniswapV3PoolActions#mint must implement this interface
                      interface IUniswapV3MintCallback {
                          /// @notice Called to `msg.sender` after minting liquidity to a position from IUniswapV3Pool#mint.
                          /// @dev In the implementation you must pay the pool tokens owed for the minted liquidity.
                          /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
                          /// @param amount0Owed The amount of token0 due to the pool for the minted liquidity
                          /// @param amount1Owed The amount of token1 due to the pool for the minted liquidity
                          /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#mint call
                          function uniswapV3MintCallback(
                              uint256 amount0Owed,
                              uint256 amount1Owed,
                              bytes calldata data
                          ) external;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Callback for IUniswapV3PoolActions#swap
                      /// @notice Any contract that calls IUniswapV3PoolActions#swap must implement this interface
                      interface IUniswapV3SwapCallback {
                          /// @notice Called to `msg.sender` after executing a swap via IUniswapV3Pool#swap.
                          /// @dev In the implementation you must pay the pool tokens owed for the swap.
                          /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
                          /// amount0Delta and amount1Delta can both be 0 if no tokens were swapped.
                          /// @param amount0Delta The amount of token0 that was sent (negative) or must be received (positive) by the pool by
                          /// the end of the swap. If positive, the callback must send that amount of token0 to the pool.
                          /// @param amount1Delta The amount of token1 that was sent (negative) or must be received (positive) by the pool by
                          /// the end of the swap. If positive, the callback must send that amount of token1 to the pool.
                          /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#swap call
                          function uniswapV3SwapCallback(
                              int256 amount0Delta,
                              int256 amount1Delta,
                              bytes calldata data
                          ) external;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Callback for IUniswapV3PoolActions#flash
                      /// @notice Any contract that calls IUniswapV3PoolActions#flash must implement this interface
                      interface IUniswapV3FlashCallback {
                          /// @notice Called to `msg.sender` after transferring to the recipient from IUniswapV3Pool#flash.
                          /// @dev In the implementation you must repay the pool the tokens sent by flash plus the computed fee amounts.
                          /// The caller of this method must be checked to be a UniswapV3Pool deployed by the canonical UniswapV3Factory.
                          /// @param fee0 The fee amount in token0 due to the pool by the end of the flash
                          /// @param fee1 The fee amount in token1 due to the pool by the end of the flash
                          /// @param data Any data passed through by the caller via the IUniswapV3PoolActions#flash call
                          function uniswapV3FlashCallback(
                              uint256 fee0,
                              uint256 fee1,
                              bytes calldata data
                          ) external;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Pool state that never changes
                      /// @notice These parameters are fixed for a pool forever, i.e., the methods will always return the same values
                      interface IUniswapV3PoolImmutables {
                          /// @notice The contract that deployed the pool, which must adhere to the IUniswapV3Factory interface
                          /// @return The contract address
                          function factory() external view returns (address);
                          /// @notice The first of the two tokens of the pool, sorted by address
                          /// @return The token contract address
                          function token0() external view returns (address);
                          /// @notice The second of the two tokens of the pool, sorted by address
                          /// @return The token contract address
                          function token1() external view returns (address);
                          /// @notice The pool's fee in hundredths of a bip, i.e. 1e-6
                          /// @return The fee
                          function fee() external view returns (uint24);
                          /// @notice The pool tick spacing
                          /// @dev Ticks can only be used at multiples of this value, minimum of 1 and always positive
                          /// e.g.: a tickSpacing of 3 means ticks can be initialized every 3rd tick, i.e., ..., -6, -3, 0, 3, 6, ...
                          /// This value is an int24 to avoid casting even though it is always positive.
                          /// @return The tick spacing
                          function tickSpacing() external view returns (int24);
                          /// @notice The maximum amount of position liquidity that can use any tick in the range
                          /// @dev This parameter is enforced per tick to prevent liquidity from overflowing a uint128 at any point, and
                          /// also prevents out-of-range liquidity from being used to prevent adding in-range liquidity to a pool
                          /// @return The max amount of liquidity per tick
                          function maxLiquidityPerTick() external view returns (uint128);
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Pool state that can change
                      /// @notice These methods compose the pool's state, and can change with any frequency including multiple times
                      /// per transaction
                      interface IUniswapV3PoolState {
                          /// @notice The 0th storage slot in the pool stores many values, and is exposed as a single method to save gas
                          /// when accessed externally.
                          /// @return sqrtPriceX96 The current price of the pool as a sqrt(token1/token0) Q64.96 value
                          /// tick The current tick of the pool, i.e. according to the last tick transition that was run.
                          /// This value may not always be equal to SqrtTickMath.getTickAtSqrtRatio(sqrtPriceX96) if the price is on a tick
                          /// boundary.
                          /// observationIndex The index of the last oracle observation that was written,
                          /// observationCardinality The current maximum number of observations stored in the pool,
                          /// observationCardinalityNext The next maximum number of observations, to be updated when the observation.
                          /// feeProtocol The protocol fee for both tokens of the pool.
                          /// Encoded as two 4 bit values, where the protocol fee of token1 is shifted 4 bits and the protocol fee of token0
                          /// is the lower 4 bits. Used as the denominator of a fraction of the swap fee, e.g. 4 means 1/4th of the swap fee.
                          /// unlocked Whether the pool is currently locked to reentrancy
                          function slot0()
                              external
                              view
                              returns (
                                  uint160 sqrtPriceX96,
                                  int24 tick,
                                  uint16 observationIndex,
                                  uint16 observationCardinality,
                                  uint16 observationCardinalityNext,
                                  uint8 feeProtocol,
                                  bool unlocked
                              );
                          /// @notice The fee growth as a Q128.128 fees of token0 collected per unit of liquidity for the entire life of the pool
                          /// @dev This value can overflow the uint256
                          function feeGrowthGlobal0X128() external view returns (uint256);
                          /// @notice The fee growth as a Q128.128 fees of token1 collected per unit of liquidity for the entire life of the pool
                          /// @dev This value can overflow the uint256
                          function feeGrowthGlobal1X128() external view returns (uint256);
                          /// @notice The amounts of token0 and token1 that are owed to the protocol
                          /// @dev Protocol fees will never exceed uint128 max in either token
                          function protocolFees() external view returns (uint128 token0, uint128 token1);
                          /// @notice The currently in range liquidity available to the pool
                          /// @dev This value has no relationship to the total liquidity across all ticks
                          function liquidity() external view returns (uint128);
                          /// @notice Look up information about a specific tick in the pool
                          /// @param tick The tick to look up
                          /// @return liquidityGross the total amount of position liquidity that uses the pool either as tick lower or
                          /// tick upper,
                          /// liquidityNet how much liquidity changes when the pool price crosses the tick,
                          /// feeGrowthOutside0X128 the fee growth on the other side of the tick from the current tick in token0,
                          /// feeGrowthOutside1X128 the fee growth on the other side of the tick from the current tick in token1,
                          /// tickCumulativeOutside the cumulative tick value on the other side of the tick from the current tick
                          /// secondsPerLiquidityOutsideX128 the seconds spent per liquidity on the other side of the tick from the current tick,
                          /// secondsOutside the seconds spent on the other side of the tick from the current tick,
                          /// initialized Set to true if the tick is initialized, i.e. liquidityGross is greater than 0, otherwise equal to false.
                          /// Outside values can only be used if the tick is initialized, i.e. if liquidityGross is greater than 0.
                          /// In addition, these values are only relative and must be used only in comparison to previous snapshots for
                          /// a specific position.
                          function ticks(int24 tick)
                              external
                              view
                              returns (
                                  uint128 liquidityGross,
                                  int128 liquidityNet,
                                  uint256 feeGrowthOutside0X128,
                                  uint256 feeGrowthOutside1X128,
                                  int56 tickCumulativeOutside,
                                  uint160 secondsPerLiquidityOutsideX128,
                                  uint32 secondsOutside,
                                  bool initialized
                              );
                          /// @notice Returns 256 packed tick initialized boolean values. See TickBitmap for more information
                          function tickBitmap(int16 wordPosition) external view returns (uint256);
                          /// @notice Returns the information about a position by the position's key
                          /// @param key The position's key is a hash of a preimage composed by the owner, tickLower and tickUpper
                          /// @return _liquidity The amount of liquidity in the position,
                          /// Returns feeGrowthInside0LastX128 fee growth of token0 inside the tick range as of the last mint/burn/poke,
                          /// Returns feeGrowthInside1LastX128 fee growth of token1 inside the tick range as of the last mint/burn/poke,
                          /// Returns tokensOwed0 the computed amount of token0 owed to the position as of the last mint/burn/poke,
                          /// Returns tokensOwed1 the computed amount of token1 owed to the position as of the last mint/burn/poke
                          function positions(bytes32 key)
                              external
                              view
                              returns (
                                  uint128 _liquidity,
                                  uint256 feeGrowthInside0LastX128,
                                  uint256 feeGrowthInside1LastX128,
                                  uint128 tokensOwed0,
                                  uint128 tokensOwed1
                              );
                          /// @notice Returns data about a specific observation index
                          /// @param index The element of the observations array to fetch
                          /// @dev You most likely want to use #observe() instead of this method to get an observation as of some amount of time
                          /// ago, rather than at a specific index in the array.
                          /// @return blockTimestamp The timestamp of the observation,
                          /// Returns tickCumulative the tick multiplied by seconds elapsed for the life of the pool as of the observation timestamp,
                          /// Returns secondsPerLiquidityCumulativeX128 the seconds per in range liquidity for the life of the pool as of the observation timestamp,
                          /// Returns initialized whether the observation has been initialized and the values are safe to use
                          function observations(uint256 index)
                              external
                              view
                              returns (
                                  uint32 blockTimestamp,
                                  int56 tickCumulative,
                                  uint160 secondsPerLiquidityCumulativeX128,
                                  bool initialized
                              );
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Pool state that is not stored
                      /// @notice Contains view functions to provide information about the pool that is computed rather than stored on the
                      /// blockchain. The functions here may have variable gas costs.
                      interface IUniswapV3PoolDerivedState {
                          /// @notice Returns the cumulative tick and liquidity as of each timestamp `secondsAgo` from the current block timestamp
                          /// @dev To get a time weighted average tick or liquidity-in-range, you must call this with two values, one representing
                          /// the beginning of the period and another for the end of the period. E.g., to get the last hour time-weighted average tick,
                          /// you must call it with secondsAgos = [3600, 0].
                          /// @dev The time weighted average tick represents the geometric time weighted average price of the pool, in
                          /// log base sqrt(1.0001) of token1 / token0. The TickMath library can be used to go from a tick value to a ratio.
                          /// @param secondsAgos From how long ago each cumulative tick and liquidity value should be returned
                          /// @return tickCumulatives Cumulative tick values as of each `secondsAgos` from the current block timestamp
                          /// @return secondsPerLiquidityCumulativeX128s Cumulative seconds per liquidity-in-range value as of each `secondsAgos` from the current block
                          /// timestamp
                          function observe(uint32[] calldata secondsAgos)
                              external
                              view
                              returns (int56[] memory tickCumulatives, uint160[] memory secondsPerLiquidityCumulativeX128s);
                          /// @notice Returns a snapshot of the tick cumulative, seconds per liquidity and seconds inside a tick range
                          /// @dev Snapshots must only be compared to other snapshots, taken over a period for which a position existed.
                          /// I.e., snapshots cannot be compared if a position is not held for the entire period between when the first
                          /// snapshot is taken and the second snapshot is taken.
                          /// @param tickLower The lower tick of the range
                          /// @param tickUpper The upper tick of the range
                          /// @return tickCumulativeInside The snapshot of the tick accumulator for the range
                          /// @return secondsPerLiquidityInsideX128 The snapshot of seconds per liquidity for the range
                          /// @return secondsInside The snapshot of seconds per liquidity for the range
                          function snapshotCumulativesInside(int24 tickLower, int24 tickUpper)
                              external
                              view
                              returns (
                                  int56 tickCumulativeInside,
                                  uint160 secondsPerLiquidityInsideX128,
                                  uint32 secondsInside
                              );
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Permissionless pool actions
                      /// @notice Contains pool methods that can be called by anyone
                      interface IUniswapV3PoolActions {
                          /// @notice Sets the initial price for the pool
                          /// @dev Price is represented as a sqrt(amountToken1/amountToken0) Q64.96 value
                          /// @param sqrtPriceX96 the initial sqrt price of the pool as a Q64.96
                          function initialize(uint160 sqrtPriceX96) external;
                          /// @notice Adds liquidity for the given recipient/tickLower/tickUpper position
                          /// @dev The caller of this method receives a callback in the form of IUniswapV3MintCallback#uniswapV3MintCallback
                          /// in which they must pay any token0 or token1 owed for the liquidity. The amount of token0/token1 due depends
                          /// on tickLower, tickUpper, the amount of liquidity, and the current price.
                          /// @param recipient The address for which the liquidity will be created
                          /// @param tickLower The lower tick of the position in which to add liquidity
                          /// @param tickUpper The upper tick of the position in which to add liquidity
                          /// @param amount The amount of liquidity to mint
                          /// @param data Any data that should be passed through to the callback
                          /// @return amount0 The amount of token0 that was paid to mint the given amount of liquidity. Matches the value in the callback
                          /// @return amount1 The amount of token1 that was paid to mint the given amount of liquidity. Matches the value in the callback
                          function mint(
                              address recipient,
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount,
                              bytes calldata data
                          ) external returns (uint256 amount0, uint256 amount1);
                          /// @notice Collects tokens owed to a position
                          /// @dev Does not recompute fees earned, which must be done either via mint or burn of any amount of liquidity.
                          /// Collect must be called by the position owner. To withdraw only token0 or only token1, amount0Requested or
                          /// amount1Requested may be set to zero. To withdraw all tokens owed, caller may pass any value greater than the
                          /// actual tokens owed, e.g. type(uint128).max. Tokens owed may be from accumulated swap fees or burned liquidity.
                          /// @param recipient The address which should receive the fees collected
                          /// @param tickLower The lower tick of the position for which to collect fees
                          /// @param tickUpper The upper tick of the position for which to collect fees
                          /// @param amount0Requested How much token0 should be withdrawn from the fees owed
                          /// @param amount1Requested How much token1 should be withdrawn from the fees owed
                          /// @return amount0 The amount of fees collected in token0
                          /// @return amount1 The amount of fees collected in token1
                          function collect(
                              address recipient,
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount0Requested,
                              uint128 amount1Requested
                          ) external returns (uint128 amount0, uint128 amount1);
                          /// @notice Burn liquidity from the sender and account tokens owed for the liquidity to the position
                          /// @dev Can be used to trigger a recalculation of fees owed to a position by calling with an amount of 0
                          /// @dev Fees must be collected separately via a call to #collect
                          /// @param tickLower The lower tick of the position for which to burn liquidity
                          /// @param tickUpper The upper tick of the position for which to burn liquidity
                          /// @param amount How much liquidity to burn
                          /// @return amount0 The amount of token0 sent to the recipient
                          /// @return amount1 The amount of token1 sent to the recipient
                          function burn(
                              int24 tickLower,
                              int24 tickUpper,
                              uint128 amount
                          ) external returns (uint256 amount0, uint256 amount1);
                          /// @notice Swap token0 for token1, or token1 for token0
                          /// @dev The caller of this method receives a callback in the form of IUniswapV3SwapCallback#uniswapV3SwapCallback
                          /// @param recipient The address to receive the output of the swap
                          /// @param zeroForOne The direction of the swap, true for token0 to token1, false for token1 to token0
                          /// @param amountSpecified The amount of the swap, which implicitly configures the swap as exact input (positive), or exact output (negative)
                          /// @param sqrtPriceLimitX96 The Q64.96 sqrt price limit. If zero for one, the price cannot be less than this
                          /// value after the swap. If one for zero, the price cannot be greater than this value after the swap
                          /// @param data Any data to be passed through to the callback
                          /// @return amount0 The delta of the balance of token0 of the pool, exact when negative, minimum when positive
                          /// @return amount1 The delta of the balance of token1 of the pool, exact when negative, minimum when positive
                          function swap(
                              address recipient,
                              bool zeroForOne,
                              int256 amountSpecified,
                              uint160 sqrtPriceLimitX96,
                              bytes calldata data
                          ) external returns (int256 amount0, int256 amount1);
                          /// @notice Receive token0 and/or token1 and pay it back, plus a fee, in the callback
                          /// @dev The caller of this method receives a callback in the form of IUniswapV3FlashCallback#uniswapV3FlashCallback
                          /// @dev Can be used to donate underlying tokens pro-rata to currently in-range liquidity providers by calling
                          /// with 0 amount{0,1} and sending the donation amount(s) from the callback
                          /// @param recipient The address which will receive the token0 and token1 amounts
                          /// @param amount0 The amount of token0 to send
                          /// @param amount1 The amount of token1 to send
                          /// @param data Any data to be passed through to the callback
                          function flash(
                              address recipient,
                              uint256 amount0,
                              uint256 amount1,
                              bytes calldata data
                          ) external;
                          /// @notice Increase the maximum number of price and liquidity observations that this pool will store
                          /// @dev This method is no-op if the pool already has an observationCardinalityNext greater than or equal to
                          /// the input observationCardinalityNext.
                          /// @param observationCardinalityNext The desired minimum number of observations for the pool to store
                          function increaseObservationCardinalityNext(uint16 observationCardinalityNext) external;
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Permissioned pool actions
                      /// @notice Contains pool methods that may only be called by the factory owner
                      interface IUniswapV3PoolOwnerActions {
                          /// @notice Set the denominator of the protocol's % share of the fees
                          /// @param feeProtocol0 new protocol fee for token0 of the pool
                          /// @param feeProtocol1 new protocol fee for token1 of the pool
                          function setFeeProtocol(uint8 feeProtocol0, uint8 feeProtocol1) external;
                          /// @notice Collect the protocol fee accrued to the pool
                          /// @param recipient The address to which collected protocol fees should be sent
                          /// @param amount0Requested The maximum amount of token0 to send, can be 0 to collect fees in only token1
                          /// @param amount1Requested The maximum amount of token1 to send, can be 0 to collect fees in only token0
                          /// @return amount0 The protocol fee collected in token0
                          /// @return amount1 The protocol fee collected in token1
                          function collectProtocol(
                              address recipient,
                              uint128 amount0Requested,
                              uint128 amount1Requested
                          ) external returns (uint128 amount0, uint128 amount1);
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Events emitted by a pool
                      /// @notice Contains all events emitted by the pool
                      interface IUniswapV3PoolEvents {
                          /// @notice Emitted exactly once by a pool when #initialize is first called on the pool
                          /// @dev Mint/Burn/Swap cannot be emitted by the pool before Initialize
                          /// @param sqrtPriceX96 The initial sqrt price of the pool, as a Q64.96
                          /// @param tick The initial tick of the pool, i.e. log base 1.0001 of the starting price of the pool
                          event Initialize(uint160 sqrtPriceX96, int24 tick);
                          /// @notice Emitted when liquidity is minted for a given position
                          /// @param sender The address that minted the liquidity
                          /// @param owner The owner of the position and recipient of any minted liquidity
                          /// @param tickLower The lower tick of the position
                          /// @param tickUpper The upper tick of the position
                          /// @param amount The amount of liquidity minted to the position range
                          /// @param amount0 How much token0 was required for the minted liquidity
                          /// @param amount1 How much token1 was required for the minted liquidity
                          event Mint(
                              address sender,
                              address indexed owner,
                              int24 indexed tickLower,
                              int24 indexed tickUpper,
                              uint128 amount,
                              uint256 amount0,
                              uint256 amount1
                          );
                          /// @notice Emitted when fees are collected by the owner of a position
                          /// @dev Collect events may be emitted with zero amount0 and amount1 when the caller chooses not to collect fees
                          /// @param owner The owner of the position for which fees are collected
                          /// @param tickLower The lower tick of the position
                          /// @param tickUpper The upper tick of the position
                          /// @param amount0 The amount of token0 fees collected
                          /// @param amount1 The amount of token1 fees collected
                          event Collect(
                              address indexed owner,
                              address recipient,
                              int24 indexed tickLower,
                              int24 indexed tickUpper,
                              uint128 amount0,
                              uint128 amount1
                          );
                          /// @notice Emitted when a position's liquidity is removed
                          /// @dev Does not withdraw any fees earned by the liquidity position, which must be withdrawn via #collect
                          /// @param owner The owner of the position for which liquidity is removed
                          /// @param tickLower The lower tick of the position
                          /// @param tickUpper The upper tick of the position
                          /// @param amount The amount of liquidity to remove
                          /// @param amount0 The amount of token0 withdrawn
                          /// @param amount1 The amount of token1 withdrawn
                          event Burn(
                              address indexed owner,
                              int24 indexed tickLower,
                              int24 indexed tickUpper,
                              uint128 amount,
                              uint256 amount0,
                              uint256 amount1
                          );
                          /// @notice Emitted by the pool for any swaps between token0 and token1
                          /// @param sender The address that initiated the swap call, and that received the callback
                          /// @param recipient The address that received the output of the swap
                          /// @param amount0 The delta of the token0 balance of the pool
                          /// @param amount1 The delta of the token1 balance of the pool
                          /// @param sqrtPriceX96 The sqrt(price) of the pool after the swap, as a Q64.96
                          /// @param liquidity The liquidity of the pool after the swap
                          /// @param tick The log base 1.0001 of price of the pool after the swap
                          event Swap(
                              address indexed sender,
                              address indexed recipient,
                              int256 amount0,
                              int256 amount1,
                              uint160 sqrtPriceX96,
                              uint128 liquidity,
                              int24 tick
                          );
                          /// @notice Emitted by the pool for any flashes of token0/token1
                          /// @param sender The address that initiated the swap call, and that received the callback
                          /// @param recipient The address that received the tokens from flash
                          /// @param amount0 The amount of token0 that was flashed
                          /// @param amount1 The amount of token1 that was flashed
                          /// @param paid0 The amount of token0 paid for the flash, which can exceed the amount0 plus the fee
                          /// @param paid1 The amount of token1 paid for the flash, which can exceed the amount1 plus the fee
                          event Flash(
                              address indexed sender,
                              address indexed recipient,
                              uint256 amount0,
                              uint256 amount1,
                              uint256 paid0,
                              uint256 paid1
                          );
                          /// @notice Emitted by the pool for increases to the number of observations that can be stored
                          /// @dev observationCardinalityNext is not the observation cardinality until an observation is written at the index
                          /// just before a mint/swap/burn.
                          /// @param observationCardinalityNextOld The previous value of the next observation cardinality
                          /// @param observationCardinalityNextNew The updated value of the next observation cardinality
                          event IncreaseObservationCardinalityNext(
                              uint16 observationCardinalityNextOld,
                              uint16 observationCardinalityNextNew
                          );
                          /// @notice Emitted when the protocol fee is changed by the pool
                          /// @param feeProtocol0Old The previous value of the token0 protocol fee
                          /// @param feeProtocol1Old The previous value of the token1 protocol fee
                          /// @param feeProtocol0New The updated value of the token0 protocol fee
                          /// @param feeProtocol1New The updated value of the token1 protocol fee
                          event SetFeeProtocol(uint8 feeProtocol0Old, uint8 feeProtocol1Old, uint8 feeProtocol0New, uint8 feeProtocol1New);
                          /// @notice Emitted when the collected protocol fees are withdrawn by the factory owner
                          /// @param sender The address that collects the protocol fees
                          /// @param recipient The address that receives the collected protocol fees
                          /// @param amount0 The amount of token0 protocol fees that is withdrawn
                          /// @param amount0 The amount of token1 protocol fees that is withdrawn
                          event CollectProtocol(address indexed sender, address indexed recipient, uint128 amount0, uint128 amount1);
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title BitMath
                      /// @dev This library provides functionality for computing bit properties of an unsigned integer
                      library BitMath {
                          /// @notice Returns the index of the most significant bit of the number,
                          ///     where the least significant bit is at index 0 and the most significant bit is at index 255
                          /// @dev The function satisfies the property:
                          ///     x >= 2**mostSignificantBit(x) and x < 2**(mostSignificantBit(x)+1)
                          /// @param x the value for which to compute the most significant bit, must be greater than 0
                          /// @return r the index of the most significant bit
                          function mostSignificantBit(uint256 x) internal pure returns (uint8 r) {
                              require(x > 0);
                              if (x >= 0x100000000000000000000000000000000) {
                                  x >>= 128;
                                  r += 128;
                              }
                              if (x >= 0x10000000000000000) {
                                  x >>= 64;
                                  r += 64;
                              }
                              if (x >= 0x100000000) {
                                  x >>= 32;
                                  r += 32;
                              }
                              if (x >= 0x10000) {
                                  x >>= 16;
                                  r += 16;
                              }
                              if (x >= 0x100) {
                                  x >>= 8;
                                  r += 8;
                              }
                              if (x >= 0x10) {
                                  x >>= 4;
                                  r += 4;
                              }
                              if (x >= 0x4) {
                                  x >>= 2;
                                  r += 2;
                              }
                              if (x >= 0x2) r += 1;
                          }
                          /// @notice Returns the index of the least significant bit of the number,
                          ///     where the least significant bit is at index 0 and the most significant bit is at index 255
                          /// @dev The function satisfies the property:
                          ///     (x & 2**leastSignificantBit(x)) != 0 and (x & (2**(leastSignificantBit(x)) - 1)) == 0)
                          /// @param x the value for which to compute the least significant bit, must be greater than 0
                          /// @return r the index of the least significant bit
                          function leastSignificantBit(uint256 x) internal pure returns (uint8 r) {
                              require(x > 0);
                              r = 255;
                              if (x & type(uint128).max > 0) {
                                  r -= 128;
                              } else {
                                  x >>= 128;
                              }
                              if (x & type(uint64).max > 0) {
                                  r -= 64;
                              } else {
                                  x >>= 64;
                              }
                              if (x & type(uint32).max > 0) {
                                  r -= 32;
                              } else {
                                  x >>= 32;
                              }
                              if (x & type(uint16).max > 0) {
                                  r -= 16;
                              } else {
                                  x >>= 16;
                              }
                              if (x & type(uint8).max > 0) {
                                  r -= 8;
                              } else {
                                  x >>= 8;
                              }
                              if (x & 0xf > 0) {
                                  r -= 4;
                              } else {
                                  x >>= 4;
                              }
                              if (x & 0x3 > 0) {
                                  r -= 2;
                              } else {
                                  x >>= 2;
                              }
                              if (x & 0x1 > 0) r -= 1;
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.5.0;
                      /// @title Math functions that do not check inputs or outputs
                      /// @notice Contains methods that perform common math functions but do not do any overflow or underflow checks
                      library UnsafeMath {
                          /// @notice Returns ceil(x / y)
                          /// @dev division by 0 has unspecified behavior, and must be checked externally
                          /// @param x The dividend
                          /// @param y The divisor
                          /// @return z The quotient, ceil(x / y)
                          function divRoundingUp(uint256 x, uint256 y) internal pure returns (uint256 z) {
                              assembly {
                                  z := add(div(x, y), gt(mod(x, y), 0))
                              }
                          }
                      }
                      // SPDX-License-Identifier: GPL-2.0-or-later
                      pragma solidity >=0.4.0;
                      /// @title FixedPoint96
                      /// @notice A library for handling binary fixed point numbers, see https://en.wikipedia.org/wiki/Q_(number_format)
                      /// @dev Used in SqrtPriceMath.sol
                      library FixedPoint96 {
                          uint8 internal constant RESOLUTION = 96;
                          uint256 internal constant Q96 = 0x1000000000000000000000000;
                      }
                      

                      File 6 of 9: LiFiDiamond
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      error TokenAddressIsZero();
                      error TokenNotSupported();
                      error CannotBridgeToSameNetwork();
                      error ZeroPostSwapBalance();
                      error NoSwapDataProvided();
                      error NativeValueWithERC();
                      error ContractCallNotAllowed();
                      error NullAddrIsNotAValidSpender();
                      error NullAddrIsNotAnERC20Token();
                      error NoTransferToNullAddress();
                      error NativeAssetTransferFailed();
                      error InvalidBridgeConfigLength();
                      error InvalidAmount();
                      error InvalidContract();
                      error InvalidConfig();
                      error UnsupportedChainId(uint256 chainId);
                      error InvalidReceiver();
                      error InvalidDestinationChain();
                      error InvalidSendingToken();
                      error InvalidCaller();
                      error AlreadyInitialized();
                      error NotInitialized();
                      error OnlyContractOwner();
                      error CannotAuthoriseSelf();
                      error RecoveryAddressCannotBeZero();
                      error CannotDepositNativeToken();
                      error InvalidCallData();
                      error NativeAssetNotSupported();
                      error UnAuthorized();
                      error NoSwapFromZeroBalance();
                      error InvalidFallbackAddress();
                      error CumulativeSlippageTooHigh(uint256 minAmount, uint256 receivedAmount);
                      error InsufficientBalance(uint256 required, uint256 balance);
                      error ZeroAmount();
                      error InvalidFee();
                      error InformationMismatch();
                      error NotAContract();
                      error NotEnoughBalance(uint256 requested, uint256 available);
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      interface IDiamondCut {
                          enum FacetCutAction {
                              Add,
                              Replace,
                              Remove
                          }
                          // Add=0, Replace=1, Remove=2
                          struct FacetCut {
                              address facetAddress;
                              FacetCutAction action;
                              bytes4[] functionSelectors;
                          }
                          /// @notice Add/replace/remove any number of functions and optionally execute
                          ///         a function with delegatecall
                          /// @param _diamondCut Contains the facet addresses and function selectors
                          /// @param _init The address of the contract or facet to execute _calldata
                          /// @param _calldata A function call, including function selector and arguments
                          ///                  _calldata is executed with delegatecall on _init
                          function diamondCut(
                              FacetCut[] calldata _diamondCut,
                              address _init,
                              bytes calldata _calldata
                          ) external;
                          event DiamondCut(FacetCut[] _diamondCut, address _init, bytes _calldata);
                      }
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      import { LibDiamond } from "./Libraries/LibDiamond.sol";
                      import { IDiamondCut } from "./Interfaces/IDiamondCut.sol";
                      import { LibUtil } from "./Libraries/LibUtil.sol";
                      contract LiFiDiamond {
                          constructor(address _contractOwner, address _diamondCutFacet) payable {
                              LibDiamond.setContractOwner(_contractOwner);
                              // Add the diamondCut external function from the diamondCutFacet
                              IDiamondCut.FacetCut[] memory cut = new IDiamondCut.FacetCut[](1);
                              bytes4[] memory functionSelectors = new bytes4[](1);
                              functionSelectors[0] = IDiamondCut.diamondCut.selector;
                              cut[0] = IDiamondCut.FacetCut({
                                  facetAddress: _diamondCutFacet,
                                  action: IDiamondCut.FacetCutAction.Add,
                                  functionSelectors: functionSelectors
                              });
                              LibDiamond.diamondCut(cut, address(0), "");
                          }
                          // Find facet for function that is called and execute the
                          // function if a facet is found and return any value.
                          // solhint-disable-next-line no-complex-fallback
                          fallback() external payable {
                              LibDiamond.DiamondStorage storage ds;
                              bytes32 position = LibDiamond.DIAMOND_STORAGE_POSITION;
                              // get diamond storage
                              // solhint-disable-next-line no-inline-assembly
                              assembly {
                                  ds.slot := position
                              }
                              // get facet from function selector
                              address facet = ds.selectorToFacetAndPosition[msg.sig].facetAddress;
                              if (facet == address(0)) {
                                  revert LibDiamond.FunctionDoesNotExist();
                              }
                              // Execute external function from facet using delegatecall and return any value.
                              // solhint-disable-next-line no-inline-assembly
                              assembly {
                                  // copy function selector and any arguments
                                  calldatacopy(0, 0, calldatasize())
                                  // execute function call using the facet
                                  let result := delegatecall(gas(), facet, 0, calldatasize(), 0, 0)
                                  // get any return value
                                  returndatacopy(0, 0, returndatasize())
                                  // return any return value or error back to the caller
                                  switch result
                                  case 0 {
                                      revert(0, returndatasize())
                                  }
                                  default {
                                      return(0, returndatasize())
                                  }
                              }
                          }
                          // Able to receive ether
                          // solhint-disable-next-line no-empty-blocks
                          receive() external payable {}
                      }
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      library LibBytes {
                          // solhint-disable no-inline-assembly
                          // LibBytes specific errors
                          error SliceOverflow();
                          error SliceOutOfBounds();
                          error AddressOutOfBounds();
                          error UintOutOfBounds();
                          // -------------------------
                          function concat(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bytes memory) {
                              bytes memory tempBytes;
                              assembly {
                                  // Get a location of some free memory and store it in tempBytes as
                                  // Solidity does for memory variables.
                                  tempBytes := mload(0x40)
                                  // Store the length of the first bytes array at the beginning of
                                  // the memory for tempBytes.
                                  let length := mload(_preBytes)
                                  mstore(tempBytes, length)
                                  // Maintain a memory counter for the current write location in the
                                  // temp bytes array by adding the 32 bytes for the array length to
                                  // the starting location.
                                  let mc := add(tempBytes, 0x20)
                                  // Stop copying when the memory counter reaches the length of the
                                  // first bytes array.
                                  let end := add(mc, length)
                                  for {
                                      // Initialize a copy counter to the start of the _preBytes data,
                                      // 32 bytes into its memory.
                                      let cc := add(_preBytes, 0x20)
                                  } lt(mc, end) {
                                      // Increase both counters by 32 bytes each iteration.
                                      mc := add(mc, 0x20)
                                      cc := add(cc, 0x20)
                                  } {
                                      // Write the _preBytes data into the tempBytes memory 32 bytes
                                      // at a time.
                                      mstore(mc, mload(cc))
                                  }
                                  // Add the length of _postBytes to the current length of tempBytes
                                  // and store it as the new length in the first 32 bytes of the
                                  // tempBytes memory.
                                  length := mload(_postBytes)
                                  mstore(tempBytes, add(length, mload(tempBytes)))
                                  // Move the memory counter back from a multiple of 0x20 to the
                                  // actual end of the _preBytes data.
                                  mc := end
                                  // Stop copying when the memory counter reaches the new combined
                                  // length of the arrays.
                                  end := add(mc, length)
                                  for {
                                      let cc := add(_postBytes, 0x20)
                                  } lt(mc, end) {
                                      mc := add(mc, 0x20)
                                      cc := add(cc, 0x20)
                                  } {
                                      mstore(mc, mload(cc))
                                  }
                                  // Update the free-memory pointer by padding our last write location
                                  // to 32 bytes: add 31 bytes to the end of tempBytes to move to the
                                  // next 32 byte block, then round down to the nearest multiple of
                                  // 32. If the sum of the length of the two arrays is zero then add
                                  // one before rounding down to leave a blank 32 bytes (the length block with 0).
                                  mstore(
                                      0x40,
                                      and(
                                          add(add(end, iszero(add(length, mload(_preBytes)))), 31),
                                          not(31) // Round down to the nearest 32 bytes.
                                      )
                                  )
                              }
                              return tempBytes;
                          }
                          function concatStorage(bytes storage _preBytes, bytes memory _postBytes) internal {
                              assembly {
                                  // Read the first 32 bytes of _preBytes storage, which is the length
                                  // of the array. (We don't need to use the offset into the slot
                                  // because arrays use the entire slot.)
                                  let fslot := sload(_preBytes.slot)
                                  // Arrays of 31 bytes or less have an even value in their slot,
                                  // while longer arrays have an odd value. The actual length is
                                  // the slot divided by two for odd values, and the lowest order
                                  // byte divided by two for even values.
                                  // If the slot is even, bitwise and the slot with 255 and divide by
                                  // two to get the length. If the slot is odd, bitwise and the slot
                                  // with -1 and divide by two.
                                  let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
                                  let mlength := mload(_postBytes)
                                  let newlength := add(slength, mlength)
                                  // slength can contain both the length and contents of the array
                                  // if length < 32 bytes so let's prepare for that
                                  // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                                  switch add(lt(slength, 32), lt(newlength, 32))
                                  case 2 {
                                      // Since the new array still fits in the slot, we just need to
                                      // update the contents of the slot.
                                      // uint256(bytes_storage) = uint256(bytes_storage) + uint256(bytes_memory) + new_length
                                      sstore(
                                          _preBytes.slot,
                                          // all the modifications to the slot are inside this
                                          // next block
                                          add(
                                              // we can just add to the slot contents because the
                                              // bytes we want to change are the LSBs
                                              fslot,
                                              add(
                                                  mul(
                                                      div(
                                                          // load the bytes from memory
                                                          mload(add(_postBytes, 0x20)),
                                                          // zero all bytes to the right
                                                          exp(0x100, sub(32, mlength))
                                                      ),
                                                      // and now shift left the number of bytes to
                                                      // leave space for the length in the slot
                                                      exp(0x100, sub(32, newlength))
                                                  ),
                                                  // increase length by the double of the memory
                                                  // bytes length
                                                  mul(mlength, 2)
                                              )
                                          )
                                      )
                                  }
                                  case 1 {
                                      // The stored value fits in the slot, but the combined value
                                      // will exceed it.
                                      // get the keccak hash to get the contents of the array
                                      mstore(0x0, _preBytes.slot)
                                      let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                                      // save new length
                                      sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                                      // The contents of the _postBytes array start 32 bytes into
                                      // the structure. Our first read should obtain the `submod`
                                      // bytes that can fit into the unused space in the last word
                                      // of the stored array. To get this, we read 32 bytes starting
                                      // from `submod`, so the data we read overlaps with the array
                                      // contents by `submod` bytes. Masking the lowest-order
                                      // `submod` bytes allows us to add that value directly to the
                                      // stored value.
                                      let submod := sub(32, slength)
                                      let mc := add(_postBytes, submod)
                                      let end := add(_postBytes, mlength)
                                      let mask := sub(exp(0x100, submod), 1)
                                      sstore(
                                          sc,
                                          add(
                                              and(fslot, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00),
                                              and(mload(mc), mask)
                                          )
                                      )
                                      for {
                                          mc := add(mc, 0x20)
                                          sc := add(sc, 1)
                                      } lt(mc, end) {
                                          sc := add(sc, 1)
                                          mc := add(mc, 0x20)
                                      } {
                                          sstore(sc, mload(mc))
                                      }
                                      mask := exp(0x100, sub(mc, end))
                                      sstore(sc, mul(div(mload(mc), mask), mask))
                                  }
                                  default {
                                      // get the keccak hash to get the contents of the array
                                      mstore(0x0, _preBytes.slot)
                                      // Start copying to the last used word of the stored array.
                                      let sc := add(keccak256(0x0, 0x20), div(slength, 32))
                                      // save new length
                                      sstore(_preBytes.slot, add(mul(newlength, 2), 1))
                                      // Copy over the first `submod` bytes of the new data as in
                                      // case 1 above.
                                      let slengthmod := mod(slength, 32)
                                      let submod := sub(32, slengthmod)
                                      let mc := add(_postBytes, submod)
                                      let end := add(_postBytes, mlength)
                                      let mask := sub(exp(0x100, submod), 1)
                                      sstore(sc, add(sload(sc), and(mload(mc), mask)))
                                      for {
                                          sc := add(sc, 1)
                                          mc := add(mc, 0x20)
                                      } lt(mc, end) {
                                          sc := add(sc, 1)
                                          mc := add(mc, 0x20)
                                      } {
                                          sstore(sc, mload(mc))
                                      }
                                      mask := exp(0x100, sub(mc, end))
                                      sstore(sc, mul(div(mload(mc), mask), mask))
                                  }
                              }
                          }
                          function slice(
                              bytes memory _bytes,
                              uint256 _start,
                              uint256 _length
                          ) internal pure returns (bytes memory) {
                              if (_length + 31 < _length) revert SliceOverflow();
                              if (_bytes.length < _start + _length) revert SliceOutOfBounds();
                              bytes memory tempBytes;
                              assembly {
                                  switch iszero(_length)
                                  case 0 {
                                      // Get a location of some free memory and store it in tempBytes as
                                      // Solidity does for memory variables.
                                      tempBytes := mload(0x40)
                                      // The first word of the slice result is potentially a partial
                                      // word read from the original array. To read it, we calculate
                                      // the length of that partial word and start copying that many
                                      // bytes into the array. The first word we copy will start with
                                      // data we don't care about, but the last `lengthmod` bytes will
                                      // land at the beginning of the contents of the new array. When
                                      // we're done copying, we overwrite the full first word with
                                      // the actual length of the slice.
                                      let lengthmod := and(_length, 31)
                                      // The multiplication in the next line is necessary
                                      // because when slicing multiples of 32 bytes (lengthmod == 0)
                                      // the following copy loop was copying the origin's length
                                      // and then ending prematurely not copying everything it should.
                                      let mc := add(add(tempBytes, lengthmod), mul(0x20, iszero(lengthmod)))
                                      let end := add(mc, _length)
                                      for {
                                          // The multiplication in the next line has the same exact purpose
                                          // as the one above.
                                          let cc := add(add(add(_bytes, lengthmod), mul(0x20, iszero(lengthmod))), _start)
                                      } lt(mc, end) {
                                          mc := add(mc, 0x20)
                                          cc := add(cc, 0x20)
                                      } {
                                          mstore(mc, mload(cc))
                                      }
                                      mstore(tempBytes, _length)
                                      //update free-memory pointer
                                      //allocating the array padded to 32 bytes like the compiler does now
                                      mstore(0x40, and(add(mc, 31), not(31)))
                                  }
                                  //if we want a zero-length slice let's just return a zero-length array
                                  default {
                                      tempBytes := mload(0x40)
                                      //zero out the 32 bytes slice we are about to return
                                      //we need to do it because Solidity does not garbage collect
                                      mstore(tempBytes, 0)
                                      mstore(0x40, add(tempBytes, 0x20))
                                  }
                              }
                              return tempBytes;
                          }
                          function toAddress(bytes memory _bytes, uint256 _start) internal pure returns (address) {
                              if (_bytes.length < _start + 20) {
                                  revert AddressOutOfBounds();
                              }
                              address tempAddress;
                              assembly {
                                  tempAddress := div(mload(add(add(_bytes, 0x20), _start)), 0x1000000000000000000000000)
                              }
                              return tempAddress;
                          }
                          function toUint8(bytes memory _bytes, uint256 _start) internal pure returns (uint8) {
                              if (_bytes.length < _start + 1) {
                                  revert UintOutOfBounds();
                              }
                              uint8 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x1), _start))
                              }
                              return tempUint;
                          }
                          function toUint16(bytes memory _bytes, uint256 _start) internal pure returns (uint16) {
                              if (_bytes.length < _start + 2) {
                                  revert UintOutOfBounds();
                              }
                              uint16 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x2), _start))
                              }
                              return tempUint;
                          }
                          function toUint32(bytes memory _bytes, uint256 _start) internal pure returns (uint32) {
                              if (_bytes.length < _start + 4) {
                                  revert UintOutOfBounds();
                              }
                              uint32 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x4), _start))
                              }
                              return tempUint;
                          }
                          function toUint64(bytes memory _bytes, uint256 _start) internal pure returns (uint64) {
                              if (_bytes.length < _start + 8) {
                                  revert UintOutOfBounds();
                              }
                              uint64 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x8), _start))
                              }
                              return tempUint;
                          }
                          function toUint96(bytes memory _bytes, uint256 _start) internal pure returns (uint96) {
                              if (_bytes.length < _start + 12) {
                                  revert UintOutOfBounds();
                              }
                              uint96 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0xc), _start))
                              }
                              return tempUint;
                          }
                          function toUint128(bytes memory _bytes, uint256 _start) internal pure returns (uint128) {
                              if (_bytes.length < _start + 16) {
                                  revert UintOutOfBounds();
                              }
                              uint128 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x10), _start))
                              }
                              return tempUint;
                          }
                          function toUint256(bytes memory _bytes, uint256 _start) internal pure returns (uint256) {
                              if (_bytes.length < _start + 32) {
                                  revert UintOutOfBounds();
                              }
                              uint256 tempUint;
                              assembly {
                                  tempUint := mload(add(add(_bytes, 0x20), _start))
                              }
                              return tempUint;
                          }
                          function toBytes32(bytes memory _bytes, uint256 _start) internal pure returns (bytes32) {
                              if (_bytes.length < _start + 32) {
                                  revert UintOutOfBounds();
                              }
                              bytes32 tempBytes32;
                              assembly {
                                  tempBytes32 := mload(add(add(_bytes, 0x20), _start))
                              }
                              return tempBytes32;
                          }
                          function equal(bytes memory _preBytes, bytes memory _postBytes) internal pure returns (bool) {
                              bool success = true;
                              assembly {
                                  let length := mload(_preBytes)
                                  // if lengths don't match the arrays are not equal
                                  switch eq(length, mload(_postBytes))
                                  case 1 {
                                      // cb is a circuit breaker in the for loop since there's
                                      //  no said feature for inline assembly loops
                                      // cb = 1 - don't breaker
                                      // cb = 0 - break
                                      let cb := 1
                                      let mc := add(_preBytes, 0x20)
                                      let end := add(mc, length)
                                      for {
                                          let cc := add(_postBytes, 0x20)
                                          // the next line is the loop condition:
                                          // while(uint256(mc < end) + cb == 2)
                                      } eq(add(lt(mc, end), cb), 2) {
                                          mc := add(mc, 0x20)
                                          cc := add(cc, 0x20)
                                      } {
                                          // if any of these checks fails then arrays are not equal
                                          if iszero(eq(mload(mc), mload(cc))) {
                                              // unsuccess:
                                              success := 0
                                              cb := 0
                                          }
                                      }
                                  }
                                  default {
                                      // unsuccess:
                                      success := 0
                                  }
                              }
                              return success;
                          }
                          function equalStorage(bytes storage _preBytes, bytes memory _postBytes) internal view returns (bool) {
                              bool success = true;
                              assembly {
                                  // we know _preBytes_offset is 0
                                  let fslot := sload(_preBytes.slot)
                                  // Decode the length of the stored array like in concatStorage().
                                  let slength := div(and(fslot, sub(mul(0x100, iszero(and(fslot, 1))), 1)), 2)
                                  let mlength := mload(_postBytes)
                                  // if lengths don't match the arrays are not equal
                                  switch eq(slength, mlength)
                                  case 1 {
                                      // slength can contain both the length and contents of the array
                                      // if length < 32 bytes so let's prepare for that
                                      // v. http://solidity.readthedocs.io/en/latest/miscellaneous.html#layout-of-state-variables-in-storage
                                      if iszero(iszero(slength)) {
                                          switch lt(slength, 32)
                                          case 1 {
                                              // blank the last byte which is the length
                                              fslot := mul(div(fslot, 0x100), 0x100)
                                              if iszero(eq(fslot, mload(add(_postBytes, 0x20)))) {
                                                  // unsuccess:
                                                  success := 0
                                              }
                                          }
                                          default {
                                              // cb is a circuit breaker in the for loop since there's
                                              //  no said feature for inline assembly loops
                                              // cb = 1 - don't breaker
                                              // cb = 0 - break
                                              let cb := 1
                                              // get the keccak hash to get the contents of the array
                                              mstore(0x0, _preBytes.slot)
                                              let sc := keccak256(0x0, 0x20)
                                              let mc := add(_postBytes, 0x20)
                                              let end := add(mc, mlength)
                                              // the next line is the loop condition:
                                              // while(uint256(mc < end) + cb == 2)
                                              // solhint-disable-next-line no-empty-blocks
                                              for {
                                              } eq(add(lt(mc, end), cb), 2) {
                                                  sc := add(sc, 1)
                                                  mc := add(mc, 0x20)
                                              } {
                                                  if iszero(eq(sload(sc), mload(mc))) {
                                                      // unsuccess:
                                                      success := 0
                                                      cb := 0
                                                  }
                                              }
                                          }
                                      }
                                  }
                                  default {
                                      // unsuccess:
                                      success := 0
                                  }
                              }
                              return success;
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      import { IDiamondCut } from "../Interfaces/IDiamondCut.sol";
                      import { LibUtil } from "../Libraries/LibUtil.sol";
                      import { OnlyContractOwner } from "../Errors/GenericErrors.sol";
                      /// Implementation of EIP-2535 Diamond Standard
                      /// https://eips.ethereum.org/EIPS/eip-2535
                      library LibDiamond {
                          bytes32 internal constant DIAMOND_STORAGE_POSITION = keccak256("diamond.standard.diamond.storage");
                          // Diamond specific errors
                          error IncorrectFacetCutAction();
                          error NoSelectorsInFace();
                          error FunctionAlreadyExists();
                          error FacetAddressIsZero();
                          error FacetAddressIsNotZero();
                          error FacetContainsNoCode();
                          error FunctionDoesNotExist();
                          error FunctionIsImmutable();
                          error InitZeroButCalldataNotEmpty();
                          error CalldataEmptyButInitNotZero();
                          error InitReverted();
                          // ----------------
                          struct FacetAddressAndPosition {
                              address facetAddress;
                              uint96 functionSelectorPosition; // position in facetFunctionSelectors.functionSelectors array
                          }
                          struct FacetFunctionSelectors {
                              bytes4[] functionSelectors;
                              uint256 facetAddressPosition; // position of facetAddress in facetAddresses array
                          }
                          struct DiamondStorage {
                              // maps function selector to the facet address and
                              // the position of the selector in the facetFunctionSelectors.selectors array
                              mapping(bytes4 => FacetAddressAndPosition) selectorToFacetAndPosition;
                              // maps facet addresses to function selectors
                              mapping(address => FacetFunctionSelectors) facetFunctionSelectors;
                              // facet addresses
                              address[] facetAddresses;
                              // Used to query if a contract implements an interface.
                              // Used to implement ERC-165.
                              mapping(bytes4 => bool) supportedInterfaces;
                              // owner of the contract
                              address contractOwner;
                          }
                          function diamondStorage() internal pure returns (DiamondStorage storage ds) {
                              bytes32 position = DIAMOND_STORAGE_POSITION;
                              // solhint-disable-next-line no-inline-assembly
                              assembly {
                                  ds.slot := position
                              }
                          }
                          event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
                          function setContractOwner(address _newOwner) internal {
                              DiamondStorage storage ds = diamondStorage();
                              address previousOwner = ds.contractOwner;
                              ds.contractOwner = _newOwner;
                              emit OwnershipTransferred(previousOwner, _newOwner);
                          }
                          function contractOwner() internal view returns (address contractOwner_) {
                              contractOwner_ = diamondStorage().contractOwner;
                          }
                          function enforceIsContractOwner() internal view {
                              if (msg.sender != diamondStorage().contractOwner) revert OnlyContractOwner();
                          }
                          event DiamondCut(IDiamondCut.FacetCut[] _diamondCut, address _init, bytes _calldata);
                          // Internal function version of diamondCut
                          function diamondCut(
                              IDiamondCut.FacetCut[] memory _diamondCut,
                              address _init,
                              bytes memory _calldata
                          ) internal {
                              for (uint256 facetIndex; facetIndex < _diamondCut.length; ) {
                                  IDiamondCut.FacetCutAction action = _diamondCut[facetIndex].action;
                                  if (action == IDiamondCut.FacetCutAction.Add) {
                                      addFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
                                  } else if (action == IDiamondCut.FacetCutAction.Replace) {
                                      replaceFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
                                  } else if (action == IDiamondCut.FacetCutAction.Remove) {
                                      removeFunctions(_diamondCut[facetIndex].facetAddress, _diamondCut[facetIndex].functionSelectors);
                                  } else {
                                      revert IncorrectFacetCutAction();
                                  }
                                  unchecked {
                                      ++facetIndex;
                                  }
                              }
                              emit DiamondCut(_diamondCut, _init, _calldata);
                              initializeDiamondCut(_init, _calldata);
                          }
                          function addFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
                              if (_functionSelectors.length == 0) {
                                  revert NoSelectorsInFace();
                              }
                              DiamondStorage storage ds = diamondStorage();
                              if (LibUtil.isZeroAddress(_facetAddress)) {
                                  revert FacetAddressIsZero();
                              }
                              uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);
                              // add new facet address if it does not exist
                              if (selectorPosition == 0) {
                                  addFacet(ds, _facetAddress);
                              }
                              for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; ) {
                                  bytes4 selector = _functionSelectors[selectorIndex];
                                  address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
                                  if (!LibUtil.isZeroAddress(oldFacetAddress)) {
                                      revert FunctionAlreadyExists();
                                  }
                                  addFunction(ds, selector, selectorPosition, _facetAddress);
                                  unchecked {
                                      ++selectorPosition;
                                      ++selectorIndex;
                                  }
                              }
                          }
                          function replaceFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
                              if (_functionSelectors.length == 0) {
                                  revert NoSelectorsInFace();
                              }
                              DiamondStorage storage ds = diamondStorage();
                              if (LibUtil.isZeroAddress(_facetAddress)) {
                                  revert FacetAddressIsZero();
                              }
                              uint96 selectorPosition = uint96(ds.facetFunctionSelectors[_facetAddress].functionSelectors.length);
                              // add new facet address if it does not exist
                              if (selectorPosition == 0) {
                                  addFacet(ds, _facetAddress);
                              }
                              for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; ) {
                                  bytes4 selector = _functionSelectors[selectorIndex];
                                  address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
                                  if (oldFacetAddress == _facetAddress) {
                                      revert FunctionAlreadyExists();
                                  }
                                  removeFunction(ds, oldFacetAddress, selector);
                                  addFunction(ds, selector, selectorPosition, _facetAddress);
                                  unchecked {
                                      ++selectorPosition;
                                      ++selectorIndex;
                                  }
                              }
                          }
                          function removeFunctions(address _facetAddress, bytes4[] memory _functionSelectors) internal {
                              if (_functionSelectors.length == 0) {
                                  revert NoSelectorsInFace();
                              }
                              DiamondStorage storage ds = diamondStorage();
                              // if function does not exist then do nothing and return
                              if (!LibUtil.isZeroAddress(_facetAddress)) {
                                  revert FacetAddressIsNotZero();
                              }
                              for (uint256 selectorIndex; selectorIndex < _functionSelectors.length; ) {
                                  bytes4 selector = _functionSelectors[selectorIndex];
                                  address oldFacetAddress = ds.selectorToFacetAndPosition[selector].facetAddress;
                                  removeFunction(ds, oldFacetAddress, selector);
                                  unchecked {
                                      ++selectorIndex;
                                  }
                              }
                          }
                          function addFacet(DiamondStorage storage ds, address _facetAddress) internal {
                              enforceHasContractCode(_facetAddress);
                              ds.facetFunctionSelectors[_facetAddress].facetAddressPosition = ds.facetAddresses.length;
                              ds.facetAddresses.push(_facetAddress);
                          }
                          function addFunction(
                              DiamondStorage storage ds,
                              bytes4 _selector,
                              uint96 _selectorPosition,
                              address _facetAddress
                          ) internal {
                              ds.selectorToFacetAndPosition[_selector].functionSelectorPosition = _selectorPosition;
                              ds.facetFunctionSelectors[_facetAddress].functionSelectors.push(_selector);
                              ds.selectorToFacetAndPosition[_selector].facetAddress = _facetAddress;
                          }
                          function removeFunction(
                              DiamondStorage storage ds,
                              address _facetAddress,
                              bytes4 _selector
                          ) internal {
                              if (LibUtil.isZeroAddress(_facetAddress)) {
                                  revert FunctionDoesNotExist();
                              }
                              // an immutable function is a function defined directly in a diamond
                              if (_facetAddress == address(this)) {
                                  revert FunctionIsImmutable();
                              }
                              // replace selector with last selector, then delete last selector
                              uint256 selectorPosition = ds.selectorToFacetAndPosition[_selector].functionSelectorPosition;
                              uint256 lastSelectorPosition = ds.facetFunctionSelectors[_facetAddress].functionSelectors.length - 1;
                              // if not the same then replace _selector with lastSelector
                              if (selectorPosition != lastSelectorPosition) {
                                  bytes4 lastSelector = ds.facetFunctionSelectors[_facetAddress].functionSelectors[lastSelectorPosition];
                                  ds.facetFunctionSelectors[_facetAddress].functionSelectors[selectorPosition] = lastSelector;
                                  ds.selectorToFacetAndPosition[lastSelector].functionSelectorPosition = uint96(selectorPosition);
                              }
                              // delete the last selector
                              ds.facetFunctionSelectors[_facetAddress].functionSelectors.pop();
                              delete ds.selectorToFacetAndPosition[_selector];
                              // if no more selectors for facet address then delete the facet address
                              if (lastSelectorPosition == 0) {
                                  // replace facet address with last facet address and delete last facet address
                                  uint256 lastFacetAddressPosition = ds.facetAddresses.length - 1;
                                  uint256 facetAddressPosition = ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;
                                  if (facetAddressPosition != lastFacetAddressPosition) {
                                      address lastFacetAddress = ds.facetAddresses[lastFacetAddressPosition];
                                      ds.facetAddresses[facetAddressPosition] = lastFacetAddress;
                                      ds.facetFunctionSelectors[lastFacetAddress].facetAddressPosition = facetAddressPosition;
                                  }
                                  ds.facetAddresses.pop();
                                  delete ds.facetFunctionSelectors[_facetAddress].facetAddressPosition;
                              }
                          }
                          function initializeDiamondCut(address _init, bytes memory _calldata) internal {
                              if (LibUtil.isZeroAddress(_init)) {
                                  if (_calldata.length != 0) {
                                      revert InitZeroButCalldataNotEmpty();
                                  }
                              } else {
                                  if (_calldata.length == 0) {
                                      revert CalldataEmptyButInitNotZero();
                                  }
                                  if (_init != address(this)) {
                                      enforceHasContractCode(_init);
                                  }
                                  // solhint-disable-next-line avoid-low-level-calls
                                  (bool success, bytes memory error) = _init.delegatecall(_calldata);
                                  if (!success) {
                                      if (error.length > 0) {
                                          // bubble up the error
                                          revert(string(error));
                                      } else {
                                          revert InitReverted();
                                      }
                                  }
                              }
                          }
                          function enforceHasContractCode(address _contract) internal view {
                              uint256 contractSize;
                              // solhint-disable-next-line no-inline-assembly
                              assembly {
                                  contractSize := extcodesize(_contract)
                              }
                              if (contractSize == 0) {
                                  revert FacetContainsNoCode();
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      pragma solidity 0.8.17;
                      import "./LibBytes.sol";
                      library LibUtil {
                          using LibBytes for bytes;
                          function getRevertMsg(bytes memory _res) internal pure returns (string memory) {
                              // If the _res length is less than 68, then the transaction failed silently (without a revert message)
                              if (_res.length < 68) return "Transaction reverted silently";
                              bytes memory revertData = _res.slice(4, _res.length - 4); // Remove the selector which is the first 4 bytes
                              return abi.decode(revertData, (string)); // All that remains is the revert string
                          }
                          /// @notice Determines whether the given address is the zero address
                          /// @param addr The address to verify
                          /// @return Boolean indicating if the address is the zero address
                          function isZeroAddress(address addr) internal pure returns (bool) {
                              return addr == address(0);
                          }
                      }
                      

                      File 7 of 9: GenericSwapFacetV3
                      // SPDX-License-Identifier: MIT
                      pragma solidity >=0.8.0 ^0.8.0 ^0.8.17 ^0.8.4;
                      
                      // lib/solmate/src/tokens/ERC20.sol
                      
                      /// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
                      /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
                      /// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
                      /// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
                      abstract contract ERC20 {
                          /*//////////////////////////////////////////////////////////////
                                                       EVENTS
                          //////////////////////////////////////////////////////////////*/
                      
                          event Transfer(address indexed from, address indexed to, uint256 amount);
                      
                          event Approval(address indexed owner, address indexed spender, uint256 amount);
                      
                          /*//////////////////////////////////////////////////////////////
                                                  METADATA STORAGE
                          //////////////////////////////////////////////////////////////*/
                      
                          string public name;
                      
                          string public symbol;
                      
                          uint8 public immutable decimals;
                      
                          /*//////////////////////////////////////////////////////////////
                                                    ERC20 STORAGE
                          //////////////////////////////////////////////////////////////*/
                      
                          uint256 public totalSupply;
                      
                          mapping(address => uint256) public balanceOf;
                      
                          mapping(address => mapping(address => uint256)) public allowance;
                      
                          /*//////////////////////////////////////////////////////////////
                                                  EIP-2612 STORAGE
                          //////////////////////////////////////////////////////////////*/
                      
                          uint256 internal immutable INITIAL_CHAIN_ID;
                      
                          bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;
                      
                          mapping(address => uint256) public nonces;
                      
                          /*//////////////////////////////////////////////////////////////
                                                     CONSTRUCTOR
                          //////////////////////////////////////////////////////////////*/
                      
                          constructor(
                              string memory _name,
                              string memory _symbol,
                              uint8 _decimals
                          ) {
                              name = _name;
                              symbol = _symbol;
                              decimals = _decimals;
                      
                              INITIAL_CHAIN_ID = block.chainid;
                              INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
                          }
                      
                          /*//////////////////////////////////////////////////////////////
                                                     ERC20 LOGIC
                          //////////////////////////////////////////////////////////////*/
                      
                          function approve(address spender, uint256 amount) public virtual returns (bool) {
                              allowance[msg.sender][spender] = amount;
                      
                              emit Approval(msg.sender, spender, amount);
                      
                              return true;
                          }
                      
                          function transfer(address to, uint256 amount) public virtual returns (bool) {
                              balanceOf[msg.sender] -= amount;
                      
                              // Cannot overflow because the sum of all user
                              // balances can't exceed the max uint256 value.
                              unchecked {
                                  balanceOf[to] += amount;
                              }
                      
                              emit Transfer(msg.sender, to, amount);
                      
                              return true;
                          }
                      
                          function transferFrom(
                              address from,
                              address to,
                              uint256 amount
                          ) public virtual returns (bool) {
                              uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.
                      
                              if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;
                      
                              balanceOf[from] -= amount;
                      
                              // Cannot overflow because the sum of all user
                              // balances can't exceed the max uint256 value.
                              unchecked {
                                  balanceOf[to] += amount;
                              }
                      
                              emit Transfer(from, to, amount);
                      
                              return true;
                          }
                      
                          /*//////////////////////////////////////////////////////////////
                                                   EIP-2612 LOGIC
                          //////////////////////////////////////////////////////////////*/
                      
                          function permit(
                              address owner,
                              address spender,
                              uint256 value,
                              uint256 deadline,
                              uint8 v,
                              bytes32 r,
                              bytes32 s
                          ) public virtual {
                              require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");
                      
                              // Unchecked because the only math done is incrementing
                              // the owner's nonce which cannot realistically overflow.
                              unchecked {
                                  address recoveredAddress = ecrecover(
                                      keccak256(
                                          abi.encodePacked(
                                              "\x19\x01",
                                              DOMAIN_SEPARATOR(),
                                              keccak256(
                                                  abi.encode(
                                                      keccak256(
                                                          "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                                      ),
                                                      owner,
                                                      spender,
                                                      value,
                                                      nonces[owner]++,
                                                      deadline
                                                  )
                                              )
                                          )
                                      ),
                                      v,
                                      r,
                                      s
                                  );
                      
                                  require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");
                      
                                  allowance[recoveredAddress][spender] = value;
                              }
                      
                              emit Approval(owner, spender, value);
                          }
                      
                          function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
                              return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
                          }
                      
                          function computeDomainSeparator() internal view virtual returns (bytes32) {
                              return
                                  keccak256(
                                      abi.encode(
                                          keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                                          keccak256(bytes(name)),
                                          keccak256("1"),
                                          block.chainid,
                                          address(this)
                                      )
                                  );
                          }
                      
                          /*//////////////////////////////////////////////////////////////
                                              INTERNAL MINT/BURN LOGIC
                          //////////////////////////////////////////////////////////////*/
                      
                          function _mint(address to, uint256 amount) internal virtual {
                              totalSupply += amount;
                      
                              // Cannot overflow because the sum of all user
                              // balances can't exceed the max uint256 value.
                              unchecked {
                                  balanceOf[to] += amount;
                              }
                      
                              emit Transfer(address(0), to, amount);
                          }
                      
                          function _burn(address from, uint256 amount) internal virtual {
                              balanceOf[from] -= amount;
                      
                              // Cannot underflow because a user's balance
                              // will never be larger than the total supply.
                              unchecked {
                                  totalSupply -= amount;
                              }
                      
                              emit Transfer(from, address(0), amount);
                          }
                      }
                      
                      // src/Errors/GenericErrors.sol
                      
                      /// @custom:version 1.0.1
                      
                      error AlreadyInitialized();
                      error CannotAuthoriseSelf();
                      error CannotBridgeToSameNetwork();
                      error ContractCallNotAllowed();
                      error CumulativeSlippageTooHigh(uint256 minAmount, uint256 receivedAmount);
                      error DiamondIsPaused();
                      error ETHTransferFailed();
                      error ExternalCallFailed();
                      error FunctionDoesNotExist();
                      error InformationMismatch();
                      error InsufficientBalance(uint256 required, uint256 balance);
                      error InvalidAmount();
                      error InvalidCallData();
                      error InvalidConfig();
                      error InvalidContract();
                      error InvalidDestinationChain();
                      error InvalidFallbackAddress();
                      error InvalidReceiver();
                      error InvalidSendingToken();
                      error NativeAssetNotSupported();
                      error NativeAssetTransferFailed();
                      error NoSwapDataProvided();
                      error NoSwapFromZeroBalance();
                      error NotAContract();
                      error NotInitialized();
                      error NoTransferToNullAddress();
                      error NullAddrIsNotAnERC20Token();
                      error NullAddrIsNotAValidSpender();
                      error OnlyContractOwner();
                      error RecoveryAddressCannotBeZero();
                      error ReentrancyError();
                      error TokenNotSupported();
                      error TransferFromFailed();
                      error UnAuthorized();
                      error UnsupportedChainId(uint256 chainId);
                      error WithdrawFailed();
                      error ZeroAmount();
                      
                      // lib/openzeppelin-contracts/contracts/token/ERC20/IERC20.sol
                      
                      // OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/IERC20.sol)
                      
                      /**
                       * @dev Interface of the ERC20 standard as defined in the EIP.
                       */
                      interface IERC20 {
                          /**
                           * @dev Emitted when `value` tokens are moved from one account (`from`) to
                           * another (`to`).
                           *
                           * Note that `value` may be zero.
                           */
                          event Transfer(address indexed from, address indexed to, uint256 value);
                      
                          /**
                           * @dev Emitted when the allowance of a `spender` for an `owner` is set by
                           * a call to {approve}. `value` is the new allowance.
                           */
                          event Approval(address indexed owner, address indexed spender, uint256 value);
                      
                          /**
                           * @dev Returns the amount of tokens in existence.
                           */
                          function totalSupply() external view returns (uint256);
                      
                          /**
                           * @dev Returns the amount of tokens owned by `account`.
                           */
                          function balanceOf(address account) external view returns (uint256);
                      
                          /**
                           * @dev Moves `amount` tokens from the caller's account to `to`.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transfer(address to, uint256 amount) external returns (bool);
                      
                          /**
                           * @dev Returns the remaining number of tokens that `spender` will be
                           * allowed to spend on behalf of `owner` through {transferFrom}. This is
                           * zero by default.
                           *
                           * This value changes when {approve} or {transferFrom} are called.
                           */
                          function allowance(address owner, address spender) external view returns (uint256);
                      
                          /**
                           * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * IMPORTANT: Beware that changing an allowance with this method brings the risk
                           * that someone may use both the old and the new allowance by unfortunate
                           * transaction ordering. One possible solution to mitigate this race
                           * condition is to first reduce the spender's allowance to 0 and set the
                           * desired value afterwards:
                           * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                           *
                           * Emits an {Approval} event.
                           */
                          function approve(address spender, uint256 amount) external returns (bool);
                      
                          /**
                           * @dev Moves `amount` tokens from `from` to `to` using the
                           * allowance mechanism. `amount` is then deducted from the caller's
                           * allowance.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transferFrom(address from, address to, uint256 amount) external returns (bool);
                      }
                      
                      // src/Interfaces/ILiFi.sol
                      
                      /// @title LIFI Interface
                      /// @author LI.FI (https://li.fi)
                      /// @custom:version 1.0.0
                      interface ILiFi {
                          /// Structs ///
                      
                          struct BridgeData {
                              bytes32 transactionId;
                              string bridge;
                              string integrator;
                              address referrer;
                              address sendingAssetId;
                              address receiver;
                              uint256 minAmount;
                              uint256 destinationChainId;
                              bool hasSourceSwaps;
                              bool hasDestinationCall;
                          }
                      
                          /// Events ///
                      
                          event LiFiTransferStarted(ILiFi.BridgeData bridgeData);
                      
                          event LiFiTransferCompleted(
                              bytes32 indexed transactionId,
                              address receivingAssetId,
                              address receiver,
                              uint256 amount,
                              uint256 timestamp
                          );
                      
                          event LiFiTransferRecovered(
                              bytes32 indexed transactionId,
                              address receivingAssetId,
                              address receiver,
                              uint256 amount,
                              uint256 timestamp
                          );
                      
                          event LiFiGenericSwapCompleted(
                              bytes32 indexed transactionId,
                              string integrator,
                              string referrer,
                              address receiver,
                              address fromAssetId,
                              address toAssetId,
                              uint256 fromAmount,
                              uint256 toAmount
                          );
                      
                          // Deprecated but kept here to include in ABI to parse historic events
                          event LiFiSwappedGeneric(
                              bytes32 indexed transactionId,
                              string integrator,
                              string referrer,
                              address fromAssetId,
                              address toAssetId,
                              uint256 fromAmount,
                              uint256 toAmount
                          );
                      }
                      
                      // src/Libraries/LibBytes.sol
                      
                      /// @custom:version 1.0.0
                      
                      library LibBytes {
                          // solhint-disable no-inline-assembly
                      
                          // LibBytes specific errors
                          error SliceOverflow();
                          error SliceOutOfBounds();
                          error AddressOutOfBounds();
                      
                          bytes16 private constant _SYMBOLS = "0123456789abcdef";
                      
                          // -------------------------
                      
                          function slice(
                              bytes memory _bytes,
                              uint256 _start,
                              uint256 _length
                          ) internal pure returns (bytes memory) {
                              if (_length + 31 < _length) revert SliceOverflow();
                              if (_bytes.length < _start + _length) revert SliceOutOfBounds();
                      
                              bytes memory tempBytes;
                      
                              assembly {
                                  switch iszero(_length)
                                  case 0 {
                                      // Get a location of some free memory and store it in tempBytes as
                                      // Solidity does for memory variables.
                                      tempBytes := mload(0x40)
                      
                                      // The first word of the slice result is potentially a partial
                                      // word read from the original array. To read it, we calculate
                                      // the length of that partial word and start copying that many
                                      // bytes into the array. The first word we copy will start with
                                      // data we don't care about, but the last `lengthmod` bytes will
                                      // land at the beginning of the contents of the new array. When
                                      // we're done copying, we overwrite the full first word with
                                      // the actual length of the slice.
                                      let lengthmod := and(_length, 31)
                      
                                      // The multiplication in the next line is necessary
                                      // because when slicing multiples of 32 bytes (lengthmod == 0)
                                      // the following copy loop was copying the origin's length
                                      // and then ending prematurely not copying everything it should.
                                      let mc := add(
                                          add(tempBytes, lengthmod),
                                          mul(0x20, iszero(lengthmod))
                                      )
                                      let end := add(mc, _length)
                      
                                      for {
                                          // The multiplication in the next line has the same exact purpose
                                          // as the one above.
                                          let cc := add(
                                              add(
                                                  add(_bytes, lengthmod),
                                                  mul(0x20, iszero(lengthmod))
                                              ),
                                              _start
                                          )
                                      } lt(mc, end) {
                                          mc := add(mc, 0x20)
                                          cc := add(cc, 0x20)
                                      } {
                                          mstore(mc, mload(cc))
                                      }
                      
                                      mstore(tempBytes, _length)
                      
                                      //update free-memory pointer
                                      //allocating the array padded to 32 bytes like the compiler does now
                                      mstore(0x40, and(add(mc, 31), not(31)))
                                  }
                                  //if we want a zero-length slice let's just return a zero-length array
                                  default {
                                      tempBytes := mload(0x40)
                                      //zero out the 32 bytes slice we are about to return
                                      //we need to do it because Solidity does not garbage collect
                                      mstore(tempBytes, 0)
                      
                                      mstore(0x40, add(tempBytes, 0x20))
                                  }
                              }
                      
                              return tempBytes;
                          }
                      
                          function toAddress(
                              bytes memory _bytes,
                              uint256 _start
                          ) internal pure returns (address) {
                              if (_bytes.length < _start + 20) {
                                  revert AddressOutOfBounds();
                              }
                              address tempAddress;
                      
                              assembly {
                                  tempAddress := div(
                                      mload(add(add(_bytes, 0x20), _start)),
                                      0x1000000000000000000000000
                                  )
                              }
                      
                              return tempAddress;
                          }
                      
                          /// Copied from OpenZeppelin's `Strings.sol` utility library.
                          /// https://github.com/OpenZeppelin/openzeppelin-contracts/blob/8335676b0e99944eef6a742e16dcd9ff6e68e609/contracts/utils/Strings.sol
                          function toHexString(
                              uint256 value,
                              uint256 length
                          ) internal pure returns (string memory) {
                              bytes memory buffer = new bytes(2 * length + 2);
                              buffer[0] = "0";
                              buffer[1] = "x";
                              for (uint256 i = 2 * length + 1; i > 1; --i) {
                                  buffer[i] = _SYMBOLS[value & 0xf];
                                  value >>= 4;
                              }
                              require(value == 0, "Strings: hex length insufficient");
                              return string(buffer);
                          }
                      }
                      
                      // lib/solady/src/utils/SafeTransferLib.sol
                      
                      /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
                      /// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
                      /// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
                      /// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)
                      ///
                      /// @dev Note:
                      /// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
                      /// - For ERC20s, this implementation won't check that a token has code,
                      ///   responsibility is delegated to the caller.
                      library SafeTransferLib_0 {
                          /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
                          /*                       CUSTOM ERRORS                        */
                          /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
                      
                          /// @dev The ETH transfer has failed.
                          error ETHTransferFailed();
                      
                          /// @dev The ERC20 `transferFrom` has failed.
                          error TransferFromFailed();
                      
                          /// @dev The ERC20 `transfer` has failed.
                          error TransferFailed();
                      
                          /// @dev The ERC20 `approve` has failed.
                          error ApproveFailed();
                      
                          /// @dev The Permit2 operation has failed.
                          error Permit2Failed();
                      
                          /// @dev The Permit2 amount must be less than `2**160 - 1`.
                          error Permit2AmountOverflow();
                      
                          /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
                          /*                         CONSTANTS                          */
                          /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
                      
                          /// @dev Suggested gas stipend for contract receiving ETH that disallows any storage writes.
                          uint256 internal constant GAS_STIPEND_NO_STORAGE_WRITES = 2300;
                      
                          /// @dev Suggested gas stipend for contract receiving ETH to perform a few
                          /// storage reads and writes, but low enough to prevent griefing.
                          uint256 internal constant GAS_STIPEND_NO_GRIEF = 100000;
                      
                          /// @dev The unique EIP-712 domain domain separator for the DAI token contract.
                          bytes32 internal constant DAI_DOMAIN_SEPARATOR =
                              0xdbb8cf42e1ecb028be3f3dbc922e1d878b963f411dc388ced501601c60f7c6f7;
                      
                          /// @dev The address for the WETH9 contract on Ethereum mainnet.
                          address internal constant WETH9 = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
                      
                          /// @dev The canonical Permit2 address.
                          /// [Github](https://github.com/Uniswap/permit2)
                          /// [Etherscan](https://etherscan.io/address/0x000000000022D473030F116dDEE9F6B43aC78BA3)
                          address internal constant PERMIT2 = 0x000000000022D473030F116dDEE9F6B43aC78BA3;
                      
                          /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
                          /*                       ETH OPERATIONS                       */
                          /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
                      
                          // If the ETH transfer MUST succeed with a reasonable gas budget, use the force variants.
                          //
                          // The regular variants:
                          // - Forwards all remaining gas to the target.
                          // - Reverts if the target reverts.
                          // - Reverts if the current contract has insufficient balance.
                          //
                          // The force variants:
                          // - Forwards with an optional gas stipend
                          //   (defaults to `GAS_STIPEND_NO_GRIEF`, which is sufficient for most cases).
                          // - If the target reverts, or if the gas stipend is exhausted,
                          //   creates a temporary contract to force send the ETH via `SELFDESTRUCT`.
                          //   Future compatible with `SENDALL`: https://eips.ethereum.org/EIPS/eip-4758.
                          // - Reverts if the current contract has insufficient balance.
                          //
                          // The try variants:
                          // - Forwards with a mandatory gas stipend.
                          // - Instead of reverting, returns whether the transfer succeeded.
                      
                          /// @dev Sends `amount` (in wei) ETH to `to`.
                          function safeTransferETH(address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  if iszero(call(gas(), to, amount, codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                              }
                          }
                      
                          /// @dev Sends all the ETH in the current contract to `to`.
                          function safeTransferAllETH(address to) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Transfer all the ETH and check if it succeeded or not.
                                  if iszero(call(gas(), to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                              }
                          }
                      
                          /// @dev Force sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
                          function forceSafeTransferETH(address to, uint256 amount, uint256 gasStipend) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  if lt(selfbalance(), amount) {
                                      mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  if iszero(call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, to) // Store the address in scratch space.
                                      mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                                      mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                                      if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
                                  }
                              }
                          }
                      
                          /// @dev Force sends all the ETH in the current contract to `to`, with a `gasStipend`.
                          function forceSafeTransferAllETH(address to, uint256 gasStipend) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  if iszero(call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, to) // Store the address in scratch space.
                                      mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                                      mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                                      if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
                                  }
                              }
                          }
                      
                          /// @dev Force sends `amount` (in wei) ETH to `to`, with `GAS_STIPEND_NO_GRIEF`.
                          function forceSafeTransferETH(address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  if lt(selfbalance(), amount) {
                                      mstore(0x00, 0xb12d13eb) // `ETHTransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  if iszero(call(GAS_STIPEND_NO_GRIEF, to, amount, codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, to) // Store the address in scratch space.
                                      mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                                      mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                                      if iszero(create(amount, 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
                                  }
                              }
                          }
                      
                          /// @dev Force sends all the ETH in the current contract to `to`, with `GAS_STIPEND_NO_GRIEF`.
                          function forceSafeTransferAllETH(address to) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // forgefmt: disable-next-item
                                  if iszero(call(GAS_STIPEND_NO_GRIEF, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)) {
                                      mstore(0x00, to) // Store the address in scratch space.
                                      mstore8(0x0b, 0x73) // Opcode `PUSH20`.
                                      mstore8(0x20, 0xff) // Opcode `SELFDESTRUCT`.
                                      if iszero(create(selfbalance(), 0x0b, 0x16)) { revert(codesize(), codesize()) } // For gas estimation.
                                  }
                              }
                          }
                      
                          /// @dev Sends `amount` (in wei) ETH to `to`, with a `gasStipend`.
                          function trySafeTransferETH(address to, uint256 amount, uint256 gasStipend)
                              internal
                              returns (bool success)
                          {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  success := call(gasStipend, to, amount, codesize(), 0x00, codesize(), 0x00)
                              }
                          }
                      
                          /// @dev Sends all the ETH in the current contract to `to`, with a `gasStipend`.
                          function trySafeTransferAllETH(address to, uint256 gasStipend)
                              internal
                              returns (bool success)
                          {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  success := call(gasStipend, to, selfbalance(), codesize(), 0x00, codesize(), 0x00)
                              }
                          }
                      
                          /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
                          /*                      ERC20 OPERATIONS                      */
                          /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
                      
                          /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
                          /// Reverts upon failure.
                          ///
                          /// The `from` account must have at least `amount` approved for
                          /// the current contract to manage.
                          function safeTransferFrom(address token, address from, address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  let m := mload(0x40) // Cache the free memory pointer.
                                  mstore(0x60, amount) // Store the `amount` argument.
                                  mstore(0x40, to) // Store the `to` argument.
                                  mstore(0x2c, shl(96, from)) // Store the `from` argument.
                                  mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
                                  // Perform the transfer, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x60, 0) // Restore the zero slot to zero.
                                  mstore(0x40, m) // Restore the free memory pointer.
                              }
                          }
                      
                          /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
                          ///
                          /// The `from` account must have at least `amount` approved for the current contract to manage.
                          function trySafeTransferFrom(address token, address from, address to, uint256 amount)
                              internal
                              returns (bool success)
                          {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  let m := mload(0x40) // Cache the free memory pointer.
                                  mstore(0x60, amount) // Store the `amount` argument.
                                  mstore(0x40, to) // Store the `to` argument.
                                  mstore(0x2c, shl(96, from)) // Store the `from` argument.
                                  mstore(0x0c, 0x23b872dd000000000000000000000000) // `transferFrom(address,address,uint256)`.
                                  success :=
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                                      )
                                  mstore(0x60, 0) // Restore the zero slot to zero.
                                  mstore(0x40, m) // Restore the free memory pointer.
                              }
                          }
                      
                          /// @dev Sends all of ERC20 `token` from `from` to `to`.
                          /// Reverts upon failure.
                          ///
                          /// The `from` account must have their entire balance approved for the current contract to manage.
                          function safeTransferAllFrom(address token, address from, address to)
                              internal
                              returns (uint256 amount)
                          {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  let m := mload(0x40) // Cache the free memory pointer.
                                  mstore(0x40, to) // Store the `to` argument.
                                  mstore(0x2c, shl(96, from)) // Store the `from` argument.
                                  mstore(0x0c, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
                                  // Read the balance, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                                          staticcall(gas(), token, 0x1c, 0x24, 0x60, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x00, 0x23b872dd) // `transferFrom(address,address,uint256)`.
                                  amount := mload(0x60) // The `amount` is already at 0x60. We'll need to return it.
                                  // Perform the transfer, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x1c, 0x64, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x7939f424) // `TransferFromFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x60, 0) // Restore the zero slot to zero.
                                  mstore(0x40, m) // Restore the free memory pointer.
                              }
                          }
                      
                          /// @dev Sends `amount` of ERC20 `token` from the current contract to `to`.
                          /// Reverts upon failure.
                          function safeTransfer(address token, address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  mstore(0x14, to) // Store the `to` argument.
                                  mstore(0x34, amount) // Store the `amount` argument.
                                  mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
                                  // Perform the transfer, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
                              }
                          }
                      
                          /// @dev Sends all of ERC20 `token` from the current contract to `to`.
                          /// Reverts upon failure.
                          function safeTransferAll(address token, address to) internal returns (uint256 amount) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  mstore(0x00, 0x70a08231) // Store the function selector of `balanceOf(address)`.
                                  mstore(0x20, address()) // Store the address of the current contract.
                                  // Read the balance, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                                          staticcall(gas(), token, 0x1c, 0x24, 0x34, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x14, to) // Store the `to` argument.
                                  amount := mload(0x34) // The `amount` is already at 0x34. We'll need to return it.
                                  mstore(0x00, 0xa9059cbb000000000000000000000000) // `transfer(address,uint256)`.
                                  // Perform the transfer, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x90b8ec18) // `TransferFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
                              }
                          }
                      
                          /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
                          /// Reverts upon failure.
                          function safeApprove(address token, address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  mstore(0x14, to) // Store the `to` argument.
                                  mstore(0x34, amount) // Store the `amount` argument.
                                  mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                                  // Perform the approval, reverting upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                                      revert(0x1c, 0x04)
                                  }
                                  mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
                              }
                          }
                      
                          /// @dev Sets `amount` of ERC20 `token` for `to` to manage on behalf of the current contract.
                          /// If the initial attempt to approve fails, attempts to reset the approved amount to zero,
                          /// then retries the approval again (some tokens, e.g. USDT, requires this).
                          /// Reverts upon failure.
                          function safeApproveWithRetry(address token, address to, uint256 amount) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  mstore(0x14, to) // Store the `to` argument.
                                  mstore(0x34, amount) // Store the `amount` argument.
                                  mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                                  // Perform the approval, retrying upon failure.
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                          call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                                      )
                                  ) {
                                      mstore(0x34, 0) // Store 0 for the `amount`.
                                      mstore(0x00, 0x095ea7b3000000000000000000000000) // `approve(address,uint256)`.
                                      pop(call(gas(), token, 0, 0x10, 0x44, codesize(), 0x00)) // Reset the approval.
                                      mstore(0x34, amount) // Store back the original `amount`.
                                      // Retry the approval, reverting upon failure.
                                      if iszero(
                                          and(
                                              or(eq(mload(0x00), 1), iszero(returndatasize())), // Returned 1 or nothing.
                                              call(gas(), token, 0, 0x10, 0x44, 0x00, 0x20)
                                          )
                                      ) {
                                          mstore(0x00, 0x3e3f8f73) // `ApproveFailed()`.
                                          revert(0x1c, 0x04)
                                      }
                                  }
                                  mstore(0x34, 0) // Restore the part of the free memory pointer that was overwritten.
                              }
                          }
                      
                          /// @dev Returns the amount of ERC20 `token` owned by `account`.
                          /// Returns zero if the `token` does not exist.
                          function balanceOf(address token, address account) internal view returns (uint256 amount) {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  mstore(0x14, account) // Store the `account` argument.
                                  mstore(0x00, 0x70a08231000000000000000000000000) // `balanceOf(address)`.
                                  amount :=
                                      mul( // The arguments of `mul` are evaluated from right to left.
                                          mload(0x20),
                                          and( // The arguments of `and` are evaluated from right to left.
                                              gt(returndatasize(), 0x1f), // At least 32 bytes returned.
                                              staticcall(gas(), token, 0x10, 0x24, 0x20, 0x20)
                                          )
                                      )
                              }
                          }
                      
                          /// @dev Sends `amount` of ERC20 `token` from `from` to `to`.
                          /// If the initial attempt fails, try to use Permit2 to transfer the token.
                          /// Reverts upon failure.
                          ///
                          /// The `from` account must have at least `amount` approved for the current contract to manage.
                          function safeTransferFrom2(address token, address from, address to, uint256 amount) internal {
                              if (!trySafeTransferFrom(token, from, to, amount)) {
                                  permit2TransferFrom(token, from, to, amount);
                              }
                          }
                      
                          /// @dev Sends `amount` of ERC20 `token` from `from` to `to` via Permit2.
                          /// Reverts upon failure.
                          function permit2TransferFrom(address token, address from, address to, uint256 amount)
                              internal
                          {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  let m := mload(0x40)
                                  mstore(add(m, 0x74), shr(96, shl(96, token)))
                                  mstore(add(m, 0x54), amount)
                                  mstore(add(m, 0x34), to)
                                  mstore(add(m, 0x20), shl(96, from))
                                  // `transferFrom(address,address,uint160,address)`.
                                  mstore(m, 0x36c78516000000000000000000000000)
                                  let p := PERMIT2
                                  let exists := eq(chainid(), 1)
                                  if iszero(exists) { exists := iszero(iszero(extcodesize(p))) }
                                  if iszero(and(call(gas(), p, 0, add(m, 0x10), 0x84, codesize(), 0x00), exists)) {
                                      mstore(0x00, 0x7939f4248757f0fd) // `TransferFromFailed()` or `Permit2AmountOverflow()`.
                                      revert(add(0x18, shl(2, iszero(iszero(shr(160, amount))))), 0x04)
                                  }
                              }
                          }
                      
                          /// @dev Permit a user to spend a given amount of
                          /// another user's tokens via native EIP-2612 permit if possible, falling
                          /// back to Permit2 if native permit fails or is not implemented on the token.
                          function permit2(
                              address token,
                              address owner,
                              address spender,
                              uint256 amount,
                              uint256 deadline,
                              uint8 v,
                              bytes32 r,
                              bytes32 s
                          ) internal {
                              bool success;
                              /// @solidity memory-safe-assembly
                              assembly {
                                  for {} shl(96, xor(token, WETH9)) {} {
                                      mstore(0x00, 0x3644e515) // `DOMAIN_SEPARATOR()`.
                                      if iszero(
                                          and( // The arguments of `and` are evaluated from right to left.
                                              lt(iszero(mload(0x00)), eq(returndatasize(), 0x20)), // Returns 1 non-zero word.
                                              // Gas stipend to limit gas burn for tokens that don't refund gas when
                                              // an non-existing function is called. 5K should be enough for a SLOAD.
                                              staticcall(5000, token, 0x1c, 0x04, 0x00, 0x20)
                                          )
                                      ) { break }
                                      // After here, we can be sure that token is a contract.
                                      let m := mload(0x40)
                                      mstore(add(m, 0x34), spender)
                                      mstore(add(m, 0x20), shl(96, owner))
                                      mstore(add(m, 0x74), deadline)
                                      if eq(mload(0x00), DAI_DOMAIN_SEPARATOR) {
                                          mstore(0x14, owner)
                                          mstore(0x00, 0x7ecebe00000000000000000000000000) // `nonces(address)`.
                                          mstore(add(m, 0x94), staticcall(gas(), token, 0x10, 0x24, add(m, 0x54), 0x20))
                                          mstore(m, 0x8fcbaf0c000000000000000000000000) // `IDAIPermit.permit`.
                                          // `nonces` is already at `add(m, 0x54)`.
                                          // `1` is already stored at `add(m, 0x94)`.
                                          mstore(add(m, 0xb4), and(0xff, v))
                                          mstore(add(m, 0xd4), r)
                                          mstore(add(m, 0xf4), s)
                                          success := call(gas(), token, 0, add(m, 0x10), 0x104, codesize(), 0x00)
                                          break
                                      }
                                      mstore(m, 0xd505accf000000000000000000000000) // `IERC20Permit.permit`.
                                      mstore(add(m, 0x54), amount)
                                      mstore(add(m, 0x94), and(0xff, v))
                                      mstore(add(m, 0xb4), r)
                                      mstore(add(m, 0xd4), s)
                                      success := call(gas(), token, 0, add(m, 0x10), 0xe4, codesize(), 0x00)
                                      break
                                  }
                              }
                              if (!success) simplePermit2(token, owner, spender, amount, deadline, v, r, s);
                          }
                      
                          /// @dev Simple permit on the Permit2 contract.
                          function simplePermit2(
                              address token,
                              address owner,
                              address spender,
                              uint256 amount,
                              uint256 deadline,
                              uint8 v,
                              bytes32 r,
                              bytes32 s
                          ) internal {
                              /// @solidity memory-safe-assembly
                              assembly {
                                  let m := mload(0x40)
                                  mstore(m, 0x927da105) // `allowance(address,address,address)`.
                                  {
                                      let addressMask := shr(96, not(0))
                                      mstore(add(m, 0x20), and(addressMask, owner))
                                      mstore(add(m, 0x40), and(addressMask, token))
                                      mstore(add(m, 0x60), and(addressMask, spender))
                                      mstore(add(m, 0xc0), and(addressMask, spender))
                                  }
                                  let p := mul(PERMIT2, iszero(shr(160, amount)))
                                  if iszero(
                                      and( // The arguments of `and` are evaluated from right to left.
                                          gt(returndatasize(), 0x5f), // Returns 3 words: `amount`, `expiration`, `nonce`.
                                          staticcall(gas(), p, add(m, 0x1c), 0x64, add(m, 0x60), 0x60)
                                      )
                                  ) {
                                      mstore(0x00, 0x6b836e6b8757f0fd) // `Permit2Failed()` or `Permit2AmountOverflow()`.
                                      revert(add(0x18, shl(2, iszero(p))), 0x04)
                                  }
                                  mstore(m, 0x2b67b570) // `Permit2.permit` (PermitSingle variant).
                                  // `owner` is already `add(m, 0x20)`.
                                  // `token` is already at `add(m, 0x40)`.
                                  mstore(add(m, 0x60), amount)
                                  mstore(add(m, 0x80), 0xffffffffffff) // `expiration = type(uint48).max`.
                                  // `nonce` is already at `add(m, 0xa0)`.
                                  // `spender` is already at `add(m, 0xc0)`.
                                  mstore(add(m, 0xe0), deadline)
                                  mstore(add(m, 0x100), 0x100) // `signature` offset.
                                  mstore(add(m, 0x120), 0x41) // `signature` length.
                                  mstore(add(m, 0x140), r)
                                  mstore(add(m, 0x160), s)
                                  mstore(add(m, 0x180), shl(248, v))
                                  if iszero(call(gas(), p, 0, add(m, 0x1c), 0x184, codesize(), 0x00)) {
                                      mstore(0x00, 0x6b836e6b) // `Permit2Failed()`.
                                      revert(0x1c, 0x04)
                                  }
                              }
                          }
                      }
                      
                      // src/Libraries/LibAllowList.sol
                      
                      /// @custom:version 1.0.0
                      
                      /// @title Lib Allow List
                      /// @author LI.FI (https://li.fi)
                      /// @notice Library for managing and accessing the conract address allow list
                      library LibAllowList {
                          /// Storage ///
                          bytes32 internal constant NAMESPACE =
                              keccak256("com.lifi.library.allow.list");
                      
                          struct AllowListStorage {
                              mapping(address => bool) allowlist;
                              mapping(bytes4 => bool) selectorAllowList;
                              address[] contracts;
                          }
                      
                          /// @dev Adds a contract address to the allow list
                          /// @param _contract the contract address to add
                          function addAllowedContract(address _contract) internal {
                              _checkAddress(_contract);
                      
                              AllowListStorage storage als = _getStorage();
                      
                              if (als.allowlist[_contract]) return;
                      
                              als.allowlist[_contract] = true;
                              als.contracts.push(_contract);
                          }
                      
                          /// @dev Checks whether a contract address has been added to the allow list
                          /// @param _contract the contract address to check
                          function contractIsAllowed(
                              address _contract
                          ) internal view returns (bool) {
                              return _getStorage().allowlist[_contract];
                          }
                      
                          /// @dev Remove a contract address from the allow list
                          /// @param _contract the contract address to remove
                          function removeAllowedContract(address _contract) internal {
                              AllowListStorage storage als = _getStorage();
                      
                              if (!als.allowlist[_contract]) {
                                  return;
                              }
                      
                              als.allowlist[_contract] = false;
                      
                              uint256 length = als.contracts.length;
                              // Find the contract in the list
                              for (uint256 i = 0; i < length; i++) {
                                  if (als.contracts[i] == _contract) {
                                      // Move the last element into the place to delete
                                      als.contracts[i] = als.contracts[length - 1];
                                      // Remove the last element
                                      als.contracts.pop();
                                      break;
                                  }
                              }
                          }
                      
                          /// @dev Fetch contract addresses from the allow list
                          function getAllowedContracts() internal view returns (address[] memory) {
                              return _getStorage().contracts;
                          }
                      
                          /// @dev Add a selector to the allow list
                          /// @param _selector the selector to add
                          function addAllowedSelector(bytes4 _selector) internal {
                              _getStorage().selectorAllowList[_selector] = true;
                          }
                      
                          /// @dev Removes a selector from the allow list
                          /// @param _selector the selector to remove
                          function removeAllowedSelector(bytes4 _selector) internal {
                              _getStorage().selectorAllowList[_selector] = false;
                          }
                      
                          /// @dev Returns if selector has been added to the allow list
                          /// @param _selector the selector to check
                          function selectorIsAllowed(bytes4 _selector) internal view returns (bool) {
                              return _getStorage().selectorAllowList[_selector];
                          }
                      
                          /// @dev Fetch local storage struct
                          function _getStorage()
                              internal
                              pure
                              returns (AllowListStorage storage als)
                          {
                              bytes32 position = NAMESPACE;
                              // solhint-disable-next-line no-inline-assembly
                              assembly {
                                  als.slot := position
                              }
                          }
                      
                          /// @dev Contains business logic for validating a contract address.
                          /// @param _contract address of the dex to check
                          function _checkAddress(address _contract) private view {
                              if (_contract == address(0)) revert InvalidContract();
                      
                              if (_contract.code.length == 0) revert InvalidContract();
                          }
                      }
                      
                      // src/Libraries/LibUtil.sol
                      
                      /// @custom:version 1.0.0
                      
                      library LibUtil {
                          using LibBytes for bytes;
                      
                          function getRevertMsg(
                              bytes memory _res
                          ) internal pure returns (string memory) {
                              // If the _res length is less than 68, then the transaction failed silently (without a revert message)
                              if (_res.length < 68) return "Transaction reverted silently";
                              bytes memory revertData = _res.slice(4, _res.length - 4); // Remove the selector which is the first 4 bytes
                              return abi.decode(revertData, (string)); // All that remains is the revert string
                          }
                      
                          /// @notice Determines whether the given address is the zero address
                          /// @param addr The address to verify
                          /// @return Boolean indicating if the address is the zero address
                          function isZeroAddress(address addr) internal pure returns (bool) {
                              return addr == address(0);
                          }
                      
                          function revertWith(bytes memory data) internal pure {
                              assembly {
                                  let dataSize := mload(data) // Load the size of the data
                                  let dataPtr := add(data, 0x20) // Advance data pointer to the next word
                                  revert(dataPtr, dataSize) // Revert with the given data
                              }
                          }
                      }
                      
                      // lib/solmate/src/utils/SafeTransferLib.sol
                      
                      /// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
                      /// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
                      /// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
                      /// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
                      library SafeTransferLib_1 {
                          /*//////////////////////////////////////////////////////////////
                                                   ETH OPERATIONS
                          //////////////////////////////////////////////////////////////*/
                      
                          function safeTransferETH(address to, uint256 amount) internal {
                              bool success;
                      
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Transfer the ETH and store if it succeeded or not.
                                  success := call(gas(), to, amount, 0, 0, 0, 0)
                              }
                      
                              require(success, "ETH_TRANSFER_FAILED");
                          }
                      
                          /*//////////////////////////////////////////////////////////////
                                                  ERC20 OPERATIONS
                          //////////////////////////////////////////////////////////////*/
                      
                          function safeTransferFrom(
                              ERC20 token,
                              address from,
                              address to,
                              uint256 amount
                          ) internal {
                              bool success;
                      
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Get a pointer to some free memory.
                                  let freeMemoryPointer := mload(0x40)
                      
                                  // Write the abi-encoded calldata into memory, beginning with the function selector.
                                  mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
                                  mstore(add(freeMemoryPointer, 4), from) // Append the "from" argument.
                                  mstore(add(freeMemoryPointer, 36), to) // Append the "to" argument.
                                  mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument.
                      
                                  success := and(
                                      // Set success to whether the call reverted, if not we check it either
                                      // returned exactly 1 (can't just be non-zero data), or had no return data.
                                      or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                                      // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
                                      // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                                      // Counterintuitively, this call must be positioned second to the or() call in the
                                      // surrounding and() call or else returndatasize() will be zero during the computation.
                                      call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
                                  )
                              }
                      
                              require(success, "TRANSFER_FROM_FAILED");
                          }
                      
                          function safeTransfer(
                              ERC20 token,
                              address to,
                              uint256 amount
                          ) internal {
                              bool success;
                      
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Get a pointer to some free memory.
                                  let freeMemoryPointer := mload(0x40)
                      
                                  // Write the abi-encoded calldata into memory, beginning with the function selector.
                                  mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
                                  mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
                                  mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.
                      
                                  success := and(
                                      // Set success to whether the call reverted, if not we check it either
                                      // returned exactly 1 (can't just be non-zero data), or had no return data.
                                      or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                                      // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                                      // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                                      // Counterintuitively, this call must be positioned second to the or() call in the
                                      // surrounding and() call or else returndatasize() will be zero during the computation.
                                      call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
                                  )
                              }
                      
                              require(success, "TRANSFER_FAILED");
                          }
                      
                          function safeApprove(
                              ERC20 token,
                              address to,
                              uint256 amount
                          ) internal {
                              bool success;
                      
                              /// @solidity memory-safe-assembly
                              assembly {
                                  // Get a pointer to some free memory.
                                  let freeMemoryPointer := mload(0x40)
                      
                                  // Write the abi-encoded calldata into memory, beginning with the function selector.
                                  mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
                                  mstore(add(freeMemoryPointer, 4), to) // Append the "to" argument.
                                  mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument.
                      
                                  success := and(
                                      // Set success to whether the call reverted, if not we check it either
                                      // returned exactly 1 (can't just be non-zero data), or had no return data.
                                      or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                                      // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                                      // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                                      // Counterintuitively, this call must be positioned second to the or() call in the
                                      // surrounding and() call or else returndatasize() will be zero during the computation.
                                      call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
                                  )
                              }
                      
                              require(success, "APPROVE_FAILED");
                          }
                      }
                      
                      // src/Libraries/LibAsset.sol
                      
                      /// @title LibAsset
                      /// @custom:version 2.0.0
                      /// @notice This library contains helpers for dealing with onchain transfers
                      ///         of assets, including accounting for the native asset `assetId`
                      ///         conventions and any noncompliant ERC20 transfers
                      library LibAsset {
                          using SafeTransferLib_0 for address;
                          using SafeTransferLib_0 for address payable;
                      
                          address internal constant NULL_ADDRESS = address(0);
                      
                          address internal constant NON_EVM_ADDRESS =
                              0x11f111f111f111F111f111f111F111f111f111F1;
                      
                          /// @dev All native assets use the empty address for their asset id
                          ///      by convention
                      
                          address internal constant NATIVE_ASSETID = NULL_ADDRESS;
                      
                          /// @dev EIP-7702 delegation designator prefix for Account Abstraction
                          bytes3 internal constant DELEGATION_DESIGNATOR = 0xef0100;
                      
                          /// @notice Gets the balance of the inheriting contract for the given asset
                          /// @param assetId The asset identifier to get the balance of
                          /// @return Balance held by contracts using this library (returns 0 if assetId does not exist)
                          function getOwnBalance(address assetId) internal view returns (uint256) {
                              return
                                  isNativeAsset(assetId)
                                      ? address(this).balance
                                      : assetId.balanceOf(address(this));
                          }
                      
                          /// @notice Wrapper function to transfer a given asset (native or erc20) to
                          ///         some recipient. Should handle all non-compliant return value
                          ///         tokens as well by using the SafeERC20 contract by open zeppelin.
                          /// @param assetId Asset id for transfer (address(0) for native asset,
                          ///                token address for erc20s)
                          /// @param recipient Address to send asset to
                          /// @param amount Amount to send to given recipient
                          function transferAsset(
                              address assetId,
                              address payable recipient,
                              uint256 amount
                          ) internal {
                              if (isNativeAsset(assetId)) {
                                  transferNativeAsset(recipient, amount);
                              } else {
                                  transferERC20(assetId, recipient, amount);
                              }
                          }
                      
                          /// @notice Transfers ether from the inheriting contract to a given
                          ///         recipient
                          /// @param recipient Address to send ether to
                          /// @param amount Amount to send to given recipient
                          function transferNativeAsset(
                              address payable recipient,
                              uint256 amount
                          ) private {
                              // make sure a meaningful receiver address was provided
                              if (recipient == NULL_ADDRESS) revert InvalidReceiver();
                      
                              // transfer native asset (will revert if target reverts or contract has insufficient balance)
                              recipient.safeTransferETH(amount);
                          }
                      
                          /// @notice Transfers tokens from the inheriting contract to a given recipient
                          /// @param assetId Token address to transfer
                          /// @param recipient Address to send tokens to
                          /// @param amount Amount to send to given recipient
                          function transferERC20(
                              address assetId,
                              address recipient,
                              uint256 amount
                          ) private {
                              // make sure a meaningful receiver address was provided
                              if (recipient == NULL_ADDRESS) {
                                  revert InvalidReceiver();
                              }
                      
                              // transfer ERC20 assets (will revert if target reverts or contract has insufficient balance)
                              assetId.safeTransfer(recipient, amount);
                          }
                      
                          /// @notice Transfers tokens from a sender to a given recipient
                          /// @param assetId Token address to transfer
                          /// @param from Address of sender/owner
                          /// @param recipient Address of recipient/spender
                          /// @param amount Amount to transfer from owner to spender
                          function transferFromERC20(
                              address assetId,
                              address from,
                              address recipient,
                              uint256 amount
                          ) internal {
                              // check if native asset
                              if (isNativeAsset(assetId)) {
                                  revert NullAddrIsNotAnERC20Token();
                              }
                      
                              // make sure a meaningful receiver address was provided
                              if (recipient == NULL_ADDRESS) {
                                  revert InvalidReceiver();
                              }
                      
                              // transfer ERC20 assets (will revert if target reverts or contract has insufficient balance)
                              assetId.safeTransferFrom(from, recipient, amount);
                          }
                      
                          /// @notice Pulls tokens from msg.sender
                          /// @param assetId Token address to transfer
                          /// @param amount Amount to transfer from owner
                          function depositAsset(address assetId, uint256 amount) internal {
                              // make sure a meaningful amount was provided
                              if (amount == 0) revert InvalidAmount();
                      
                              // check if native asset
                              if (isNativeAsset(assetId)) {
                                  // ensure msg.value is equal or greater than amount
                                  if (msg.value < amount) revert InvalidAmount();
                              } else {
                                  // transfer ERC20 assets (will revert if target reverts or contract has insufficient balance)
                                  assetId.safeTransferFrom(msg.sender, address(this), amount);
                              }
                          }
                      
                          function depositAssets(LibSwap.SwapData[] calldata swaps) internal {
                              for (uint256 i = 0; i < swaps.length; ) {
                                  LibSwap.SwapData calldata swap = swaps[i];
                                  if (swap.requiresDeposit) {
                                      depositAsset(swap.sendingAssetId, swap.fromAmount);
                                  }
                                  unchecked {
                                      i++;
                                  }
                              }
                          }
                      
                          /// @notice If the current allowance is insufficient, the allowance for a given spender
                          ///         is set to MAX_UINT.
                          /// @param assetId Token address to transfer
                          /// @param spender Address to give spend approval to
                          /// @param amount allowance amount required for current transaction
                          function maxApproveERC20(
                              IERC20 assetId,
                              address spender,
                              uint256 amount
                          ) internal {
                              approveERC20(assetId, spender, amount, type(uint256).max);
                          }
                      
                          /// @notice If the current allowance is insufficient, the allowance for a given spender
                          ///         is set to the amount provided
                          /// @param assetId Token address to transfer
                          /// @param spender Address to give spend approval to
                          /// @param requiredAllowance Allowance required for current transaction
                          /// @param setAllowanceTo The amount the allowance should be set to if current allowance is insufficient
                          function approveERC20(
                              IERC20 assetId,
                              address spender,
                              uint256 requiredAllowance,
                              uint256 setAllowanceTo
                          ) internal {
                              if (isNativeAsset(address(assetId))) {
                                  return;
                              }
                      
                              // make sure a meaningful spender address was provided
                              if (spender == NULL_ADDRESS) {
                                  revert NullAddrIsNotAValidSpender();
                              }
                      
                              // check if allowance is sufficient, otherwise set allowance to provided amount
                              // If the initial attempt to approve fails, attempts to reset the approved amount to zero,
                              // then retries the approval again (some tokens, e.g. USDT, requires this).
                              // Reverts upon failure
                              if (assetId.allowance(address(this), spender) < requiredAllowance) {
                                  address(assetId).safeApproveWithRetry(spender, setAllowanceTo);
                              }
                          }
                      
                          /// @notice Determines whether the given assetId is the native asset
                          /// @param assetId The asset identifier to evaluate
                          /// @return Boolean indicating if the asset is the native asset
                          function isNativeAsset(address assetId) internal pure returns (bool) {
                              return assetId == NATIVE_ASSETID;
                          }
                      
                          /// @notice Checks if the given address is a contract (including EIP‑7702 AA‑wallets)
                          ///         Returns true for any account with runtime code or with the 0xef0100 prefix (EIP‑7702).
                          ///         Limitations:
                          ///         - Still returns false during construction phase of a contract
                          ///         - Cannot distinguish between EOA and self-destructed contract
                          /// @param account The address to be checked
                          function isContract(address account) internal view returns (bool) {
                              bytes memory code = new bytes(23); // 3 bytes prefix + 20 bytes address
                      
                              assembly {
                                  extcodecopy(account, add(code, 0x20), 0, 23)
                              }
                      
                              // Check for delegation designator prefix
                              bytes3 prefix;
                              assembly {
                                  prefix := mload(add(code, 32))
                              }
                      
                              if (prefix == DELEGATION_DESIGNATOR) {
                                  // Extract delegate address (next 20 bytes)
                                  address delegateAddr;
                                  assembly {
                                      delegateAddr := mload(add(add(code, 0x20), 3))
                                      delegateAddr := shr(96, delegateAddr)
                                  }
                      
                                  // Only check first level of delegation
                                  uint256 delegateSize;
                                  assembly {
                                      delegateSize := extcodesize(delegateAddr)
                                  }
                                  return delegateSize > 0;
                              }
                      
                              // If not delegated, check if it's a regular contract
                              uint256 size;
                              assembly {
                                  size := extcodesize(account)
                              }
                              return size > 0;
                          }
                      }
                      
                      // src/Libraries/LibSwap.sol
                      
                      /// @title LibSwap
                      /// @custom:version 1.1.0
                      /// @notice This library contains functionality to execute mostly swaps but also
                      ///         other calls such as fee collection, token wrapping/unwrapping or
                      ///         sending gas to destination chain
                      library LibSwap {
                          /// @notice Struct containing all necessary data to execute a swap or generic call
                          /// @param callTo The address of the contract to call for executing the swap
                          /// @param approveTo The address that will receive token approval (can be different than callTo for some DEXs)
                          /// @param sendingAssetId The address of the token being sent
                          /// @param receivingAssetId The address of the token expected to be received
                          /// @param fromAmount The exact amount of the sending asset to be used in the call
                          /// @param callData Encoded function call data to be sent to the `callTo` contract
                          /// @param requiresDeposit A flag indicating whether the tokens must be deposited (pulled) before the call
                          struct SwapData {
                              address callTo;
                              address approveTo;
                              address sendingAssetId;
                              address receivingAssetId;
                              uint256 fromAmount;
                              bytes callData;
                              bool requiresDeposit;
                          }
                      
                          /// @notice Emitted after a successful asset swap or related operation
                          /// @param transactionId    The unique identifier associated with the swap operation
                          /// @param dex              The address of the DEX or contract that handled the swap
                          /// @param fromAssetId      The address of the token that was sent
                          /// @param toAssetId        The address of the token that was received
                          /// @param fromAmount       The amount of `fromAssetId` sent
                          /// @param toAmount         The amount of `toAssetId` received
                          /// @param timestamp        The timestamp when the swap was executed
                          event AssetSwapped(
                              bytes32 transactionId,
                              address dex,
                              address fromAssetId,
                              address toAssetId,
                              uint256 fromAmount,
                              uint256 toAmount,
                              uint256 timestamp
                          );
                      
                          function swap(bytes32 transactionId, SwapData calldata _swap) internal {
                              // make sure callTo is a contract
                              if (!LibAsset.isContract(_swap.callTo)) revert InvalidContract();
                      
                              // make sure that fromAmount is not 0
                              uint256 fromAmount = _swap.fromAmount;
                              if (fromAmount == 0) revert NoSwapFromZeroBalance();
                      
                              // determine how much native value to send with the swap call
                              uint256 nativeValue = LibAsset.isNativeAsset(_swap.sendingAssetId)
                                  ? _swap.fromAmount
                                  : 0;
                      
                              // store initial balance (required for event emission)
                              uint256 initialReceivingAssetBalance = LibAsset.getOwnBalance(
                                  _swap.receivingAssetId
                              );
                      
                              // max approve (if ERC20)
                              if (nativeValue == 0) {
                                  LibAsset.maxApproveERC20(
                                      IERC20(_swap.sendingAssetId),
                                      _swap.approveTo,
                                      _swap.fromAmount
                                  );
                              }
                      
                              // we used to have a sending asset balance check here (initialSendingAssetBalance >= _swap.fromAmount)
                              // this check was removed to allow for more flexibility with rebasing/fee-taking tokens
                              // the general assumption is that if not enough tokens are available to execute the calldata, the transaction will fail anyway
                              // the error message might not be as explicit though
                      
                              // execute the swap
                              // solhint-disable-next-line avoid-low-level-calls
                              (bool success, bytes memory res) = _swap.callTo.call{
                                  value: nativeValue
                              }(_swap.callData);
                              if (!success) {
                                  LibUtil.revertWith(res);
                              }
                      
                              // get post-swap balance
                              uint256 newBalance = LibAsset.getOwnBalance(_swap.receivingAssetId);
                      
                              // emit event
                              emit AssetSwapped(
                                  transactionId,
                                  _swap.callTo,
                                  _swap.sendingAssetId,
                                  _swap.receivingAssetId,
                                  _swap.fromAmount,
                                  newBalance > initialReceivingAssetBalance
                                      ? newBalance - initialReceivingAssetBalance
                                      : newBalance,
                                  block.timestamp
                              );
                          }
                      }
                      
                      // src/Facets/GenericSwapFacetV3.sol
                      
                      /// @title GenericSwapFacetV3
                      /// @author LI.FI (https://li.fi)
                      /// @notice Provides gas-optimized functionality for fee collection and for swapping through any APPROVED DEX
                      /// @dev Can only execute calldata for APPROVED function selectors
                      /// @custom:version 1.0.2
                      contract GenericSwapFacetV3 is ILiFi {
                          using SafeTransferLib_1 for ERC20;
                      
                          /// Storage
                          address public immutable NATIVE_ADDRESS;
                      
                          /// Constructor
                          /// @param _nativeAddress the address of the native token for this network
                          constructor(address _nativeAddress) {
                              NATIVE_ADDRESS = _nativeAddress;
                          }
                      
                          /// External Methods ///
                      
                          // SINGLE SWAPS
                      
                          /// @notice Performs a single swap from an ERC20 token to another ERC20 token
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensSingleV3ERC20ToERC20(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData calldata _swapData
                          ) external {
                              _depositAndSwapERC20Single(_swapData, _receiver);
                      
                              address receivingAssetId = _swapData.receivingAssetId;
                              address sendingAssetId = _swapData.sendingAssetId;
                      
                              // get contract's balance (which will be sent in full to user)
                              uint256 amountReceived = ERC20(receivingAssetId).balanceOf(
                                  address(this)
                              );
                      
                              // ensure that minAmountOut was received
                              if (amountReceived < _minAmountOut)
                                  revert CumulativeSlippageTooHigh(_minAmountOut, amountReceived);
                      
                              // transfer funds to receiver
                              ERC20(receivingAssetId).safeTransfer(_receiver, amountReceived);
                      
                              // emit events (both required for tracking)
                              uint256 fromAmount = _swapData.fromAmount;
                              emit LibSwap.AssetSwapped(
                                  _transactionId,
                                  _swapData.callTo,
                                  sendingAssetId,
                                  receivingAssetId,
                                  fromAmount,
                                  amountReceived,
                                  block.timestamp
                              );
                      
                              emit ILiFi.LiFiGenericSwapCompleted(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  sendingAssetId,
                                  receivingAssetId,
                                  fromAmount,
                                  amountReceived
                              );
                          }
                      
                          /// @notice Performs a single swap from an ERC20 token to the network's native token
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensSingleV3ERC20ToNative(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData calldata _swapData
                          ) external {
                              _depositAndSwapERC20Single(_swapData, _receiver);
                      
                              // get contract's balance (which will be sent in full to user)
                              uint256 amountReceived = address(this).balance;
                      
                              // ensure that minAmountOut was received
                              if (amountReceived < _minAmountOut)
                                  revert CumulativeSlippageTooHigh(_minAmountOut, amountReceived);
                      
                              // transfer funds to receiver
                              // solhint-disable-next-line avoid-low-level-calls
                              (bool success, ) = _receiver.call{ value: amountReceived }("");
                              if (!success) revert NativeAssetTransferFailed();
                      
                              // emit events (both required for tracking)
                              address sendingAssetId = _swapData.sendingAssetId;
                              uint256 fromAmount = _swapData.fromAmount;
                              emit LibSwap.AssetSwapped(
                                  _transactionId,
                                  _swapData.callTo,
                                  sendingAssetId,
                                  NATIVE_ADDRESS,
                                  fromAmount,
                                  amountReceived,
                                  block.timestamp
                              );
                      
                              emit ILiFi.LiFiGenericSwapCompleted(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  sendingAssetId,
                                  NATIVE_ADDRESS,
                                  fromAmount,
                                  amountReceived
                              );
                          }
                      
                          /// @notice Performs a single swap from the network's native token to ERC20 token
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensSingleV3NativeToERC20(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData calldata _swapData
                          ) external payable {
                              address callTo = _swapData.callTo;
                              // ensure that contract (callTo) and function selector are whitelisted
                              if (
                                  !(LibAllowList.contractIsAllowed(callTo) &&
                                      LibAllowList.selectorIsAllowed(bytes4(_swapData.callData[:4])))
                              ) revert ContractCallNotAllowed();
                      
                              // execute swap
                              // solhint-disable-next-line avoid-low-level-calls
                              (bool success, bytes memory res) = callTo.call{ value: msg.value }(
                                  _swapData.callData
                              );
                              if (!success) {
                                  LibUtil.revertWith(res);
                              }
                      
                              _returnPositiveSlippageNative(_receiver);
                      
                              // get contract's balance (which will be sent in full to user)
                              address receivingAssetId = _swapData.receivingAssetId;
                              uint256 amountReceived = ERC20(receivingAssetId).balanceOf(
                                  address(this)
                              );
                      
                              // ensure that minAmountOut was received
                              if (amountReceived < _minAmountOut)
                                  revert CumulativeSlippageTooHigh(_minAmountOut, amountReceived);
                      
                              // transfer funds to receiver
                              ERC20(receivingAssetId).safeTransfer(_receiver, amountReceived);
                      
                              // emit events (both required for tracking)
                              uint256 fromAmount = _swapData.fromAmount;
                              emit LibSwap.AssetSwapped(
                                  _transactionId,
                                  callTo,
                                  NATIVE_ADDRESS,
                                  receivingAssetId,
                                  fromAmount,
                                  amountReceived,
                                  block.timestamp
                              );
                      
                              emit ILiFi.LiFiGenericSwapCompleted(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  NATIVE_ADDRESS,
                                  receivingAssetId,
                                  fromAmount,
                                  amountReceived
                              );
                          }
                      
                          // MULTIPLE SWAPS
                      
                          /// @notice Performs multiple swaps in one transaction, starting with ERC20 and ending with native
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensMultipleV3ERC20ToNative(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData[] calldata _swapData
                          ) external {
                              _depositMultipleERC20Tokens(_swapData);
                              _executeSwaps(_swapData, _transactionId, _receiver);
                              _transferNativeTokensAndEmitEvent(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  _minAmountOut,
                                  _swapData
                              );
                          }
                      
                          /// @notice Performs multiple swaps in one transaction, starting with ERC20 and ending with ERC20
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensMultipleV3ERC20ToERC20(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData[] calldata _swapData
                          ) external {
                              _depositMultipleERC20Tokens(_swapData);
                              _executeSwaps(_swapData, _transactionId, _receiver);
                              _transferERC20TokensAndEmitEvent(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  _minAmountOut,
                                  _swapData
                              );
                          }
                      
                          /// @notice Performs multiple swaps in one transaction, starting with native and ending with ERC20
                          /// @param _transactionId the transaction id associated with the operation
                          /// @param _integrator the name of the integrator
                          /// @param _referrer the address of the referrer
                          /// @param _receiver the address to receive the swapped tokens into (also excess tokens)
                          /// @param _minAmountOut the minimum amount of the final asset to receive
                          /// @param _swapData an object containing swap related data to perform swaps before bridging
                          function swapTokensMultipleV3NativeToERC20(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData[] calldata _swapData
                          ) external payable {
                              _executeSwaps(_swapData, _transactionId, _receiver);
                              _transferERC20TokensAndEmitEvent(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  _minAmountOut,
                                  _swapData
                              );
                          }
                      
                          /// Private helper methods ///
                          function _depositMultipleERC20Tokens(
                              LibSwap.SwapData[] calldata _swapData
                          ) private {
                              // initialize variables before loop to save gas
                              uint256 numOfSwaps = _swapData.length;
                              LibSwap.SwapData calldata currentSwap;
                      
                              // go through all swaps and deposit tokens, where required
                              for (uint256 i = 0; i < numOfSwaps; ) {
                                  currentSwap = _swapData[i];
                                  if (currentSwap.requiresDeposit) {
                                      // we will not check msg.value as tx will fail anyway if not enough value available
                                      // thus we only deposit ERC20 tokens here
                                      ERC20(currentSwap.sendingAssetId).safeTransferFrom(
                                          msg.sender,
                                          address(this),
                                          currentSwap.fromAmount
                                      );
                                  }
                                  unchecked {
                                      ++i;
                                  }
                              }
                          }
                      
                          function _depositAndSwapERC20Single(
                              LibSwap.SwapData calldata _swapData,
                              address _receiver
                          ) private {
                              ERC20 sendingAsset = ERC20(_swapData.sendingAssetId);
                              uint256 fromAmount = _swapData.fromAmount;
                              // deposit funds
                              sendingAsset.safeTransferFrom(msg.sender, address(this), fromAmount);
                      
                              // ensure that contract (callTo) and function selector are whitelisted
                              address callTo = _swapData.callTo;
                              address approveTo = _swapData.approveTo;
                              bytes calldata callData = _swapData.callData;
                              if (
                                  !(LibAllowList.contractIsAllowed(callTo) &&
                                      LibAllowList.selectorIsAllowed(bytes4(callData[:4])))
                              ) revert ContractCallNotAllowed();
                      
                              // ensure that approveTo address is also whitelisted if it differs from callTo
                              if (approveTo != callTo && !LibAllowList.contractIsAllowed(approveTo))
                                  revert ContractCallNotAllowed();
                      
                              // check if the current allowance is sufficient
                              uint256 currentAllowance = sendingAsset.allowance(
                                  address(this),
                                  approveTo
                              );
                      
                              // check if existing allowance is sufficient
                              if (currentAllowance < fromAmount) {
                                  // check if is non-zero, set to 0 if not
                                  if (currentAllowance != 0) sendingAsset.safeApprove(approveTo, 0);
                                  // set allowance to uint max to avoid future approvals
                                  sendingAsset.safeApprove(approveTo, type(uint256).max);
                              }
                      
                              // execute swap
                              // solhint-disable-next-line avoid-low-level-calls
                              (bool success, bytes memory res) = callTo.call(callData);
                              if (!success) {
                                  LibUtil.revertWith(res);
                              }
                      
                              _returnPositiveSlippageERC20(sendingAsset, _receiver);
                          }
                      
                          // @dev: this function will not work with swapData that has multiple swaps with the same sendingAssetId
                          //       as the _returnPositiveSlippage... functionality will refund all remaining tokens after the first swap
                          //       We accept this fact since the use case is not common yet. As an alternative you can always use the
                          //       "swapTokensGeneric" function of the original GenericSwapFacet
                          function _executeSwaps(
                              LibSwap.SwapData[] calldata _swapData,
                              bytes32 _transactionId,
                              address _receiver
                          ) private {
                              // initialize variables before loop to save gas
                              uint256 numOfSwaps = _swapData.length;
                              ERC20 sendingAsset;
                              address sendingAssetId;
                              address receivingAssetId;
                              LibSwap.SwapData calldata currentSwap;
                              bool success;
                              bytes memory returnData;
                              uint256 currentAllowance;
                      
                              // go through all swaps
                              for (uint256 i = 0; i < numOfSwaps; ) {
                                  currentSwap = _swapData[i];
                                  sendingAssetId = currentSwap.sendingAssetId;
                                  sendingAsset = ERC20(currentSwap.sendingAssetId);
                                  receivingAssetId = currentSwap.receivingAssetId;
                      
                                  // check if callTo address is whitelisted
                                  if (
                                      !LibAllowList.contractIsAllowed(currentSwap.callTo) ||
                                      !LibAllowList.selectorIsAllowed(
                                          bytes4(currentSwap.callData[:4])
                                      )
                                  ) {
                                      revert ContractCallNotAllowed();
                                  }
                      
                                  // if approveTo address is different to callTo, check if it's whitelisted, too
                                  if (
                                      currentSwap.approveTo != currentSwap.callTo &&
                                      !LibAllowList.contractIsAllowed(currentSwap.approveTo)
                                  ) {
                                      revert ContractCallNotAllowed();
                                  }
                      
                                  if (LibAsset.isNativeAsset(sendingAssetId)) {
                                      // Native
                                      // execute the swap
                                      (success, returnData) = currentSwap.callTo.call{
                                          value: currentSwap.fromAmount
                                      }(currentSwap.callData);
                                      if (!success) {
                                          LibUtil.revertWith(returnData);
                                      }
                      
                                      // return any potential leftover sendingAsset tokens
                                      // but only for swaps, not for fee collections (otherwise the whole amount would be returned before the actual swap)
                                      if (sendingAssetId != receivingAssetId)
                                          _returnPositiveSlippageNative(_receiver);
                                  } else {
                                      // ERC20
                                      // check if the current allowance is sufficient
                                      currentAllowance = sendingAsset.allowance(
                                          address(this),
                                          currentSwap.approveTo
                                      );
                                      if (currentAllowance < currentSwap.fromAmount) {
                                          sendingAsset.safeApprove(currentSwap.approveTo, 0);
                                          sendingAsset.safeApprove(
                                              currentSwap.approveTo,
                                              type(uint256).max
                                          );
                                      }
                      
                                      // execute the swap
                                      (success, returnData) = currentSwap.callTo.call(
                                          currentSwap.callData
                                      );
                                      if (!success) {
                                          LibUtil.revertWith(returnData);
                                      }
                      
                                      // return any potential leftover sendingAsset tokens
                                      // but only for swaps, not for fee collections (otherwise the whole amount would be returned before the actual swap)
                                      if (sendingAssetId != receivingAssetId)
                                          _returnPositiveSlippageERC20(sendingAsset, _receiver);
                                  }
                      
                                  // emit AssetSwapped event
                                  // @dev: this event might in some cases emit inaccurate information. e.g. if a token is swapped and this contract already held a balance of the receivingAsset
                                  //       then the event will show swapOutputAmount + existingBalance as toAmount. We accept this potential inaccuracy in return for gas savings and may update this
                                  //       at a later stage when the described use case becomes more common
                                  emit LibSwap.AssetSwapped(
                                      _transactionId,
                                      currentSwap.callTo,
                                      sendingAssetId,
                                      receivingAssetId,
                                      currentSwap.fromAmount,
                                      LibAsset.isNativeAsset(receivingAssetId)
                                          ? address(this).balance
                                          : ERC20(receivingAssetId).balanceOf(address(this)),
                                      block.timestamp
                                  );
                      
                                  unchecked {
                                      ++i;
                                  }
                              }
                          }
                      
                          function _transferERC20TokensAndEmitEvent(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData[] calldata _swapData
                          ) private {
                              // determine the end result of the swap
                              address finalAssetId = _swapData[_swapData.length - 1]
                                  .receivingAssetId;
                              uint256 amountReceived = ERC20(finalAssetId).balanceOf(address(this));
                      
                              // make sure minAmountOut was received
                              if (amountReceived < _minAmountOut)
                                  revert CumulativeSlippageTooHigh(_minAmountOut, amountReceived);
                      
                              // transfer to receiver
                              ERC20(finalAssetId).safeTransfer(_receiver, amountReceived);
                      
                              // emit event
                              emit ILiFi.LiFiGenericSwapCompleted(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  _swapData[0].sendingAssetId,
                                  finalAssetId,
                                  _swapData[0].fromAmount,
                                  amountReceived
                              );
                          }
                      
                          function _transferNativeTokensAndEmitEvent(
                              bytes32 _transactionId,
                              string calldata _integrator,
                              string calldata _referrer,
                              address payable _receiver,
                              uint256 _minAmountOut,
                              LibSwap.SwapData[] calldata _swapData
                          ) private {
                              uint256 amountReceived = address(this).balance;
                      
                              // make sure minAmountOut was received
                              if (amountReceived < _minAmountOut)
                                  revert CumulativeSlippageTooHigh(_minAmountOut, amountReceived);
                      
                              // transfer funds to receiver
                              // solhint-disable-next-line avoid-low-level-calls
                              (bool success, ) = _receiver.call{ value: amountReceived }("");
                              if (!success) {
                                  revert NativeAssetTransferFailed();
                              }
                      
                              // emit event
                              emit ILiFi.LiFiGenericSwapCompleted(
                                  _transactionId,
                                  _integrator,
                                  _referrer,
                                  _receiver,
                                  _swapData[0].sendingAssetId,
                                  NATIVE_ADDRESS,
                                  _swapData[0].fromAmount,
                                  amountReceived
                              );
                          }
                      
                          // returns any unused 'sendingAsset' tokens (=> positive slippage) to the receiver address
                          function _returnPositiveSlippageERC20(
                              ERC20 sendingAsset,
                              address receiver
                          ) private {
                              // if a balance exists in sendingAsset, it must be positive slippage
                              if (address(sendingAsset) != NATIVE_ADDRESS) {
                                  uint256 sendingAssetBalance = sendingAsset.balanceOf(
                                      address(this)
                                  );
                      
                                  // we decided to change this value from 0 to 1 to have more flexibility with rebasing tokens that
                                  // sometimes produce rounding errors. In those cases there might be 1 wei leftover at the end of a swap
                                  // but this 1 wei is not transferable, so the tx reverts. We accept that 1 wei dust gets stuck in the contract
                                  // with every tx as this does not represent a significant USD value in any relevant token.
                                  if (sendingAssetBalance > 1) {
                                      sendingAsset.safeTransfer(receiver, sendingAssetBalance);
                                  }
                              }
                          }
                      
                          // returns any unused native tokens (=> positive slippage) to the receiver address
                          function _returnPositiveSlippageNative(address receiver) private {
                              // if a native balance exists in sendingAsset, it must be positive slippage
                              uint256 nativeBalance = address(this).balance;
                      
                              if (nativeBalance > 0) {
                                  // solhint-disable-next-line avoid-low-level-calls
                                  (bool success, ) = receiver.call{ value: nativeBalance }("");
                                  if (!success) revert NativeAssetTransferFailed();
                              }
                          }
                      }

                      File 8 of 9: RedSnwapper
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
                       * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
                       *
                       * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
                       * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
                       * need to send a transaction, and thus is not required to hold Ether at all.
                       */
                      interface IERC20Permit {
                          /**
                           * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
                           * given ``owner``'s signed approval.
                           *
                           * IMPORTANT: The same issues {IERC20-approve} has related to transaction
                           * ordering also apply here.
                           *
                           * Emits an {Approval} event.
                           *
                           * Requirements:
                           *
                           * - `spender` cannot be the zero address.
                           * - `deadline` must be a timestamp in the future.
                           * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
                           * over the EIP712-formatted function arguments.
                           * - the signature must use ``owner``'s current nonce (see {nonces}).
                           *
                           * For more information on the signature format, see the
                           * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
                           * section].
                           */
                          function permit(
                              address owner,
                              address spender,
                              uint256 value,
                              uint256 deadline,
                              uint8 v,
                              bytes32 r,
                              bytes32 s
                          ) external;
                          /**
                           * @dev Returns the current nonce for `owner`. This value must be
                           * included whenever a signature is generated for {permit}.
                           *
                           * Every successful call to {permit} increases ``owner``'s nonce by one. This
                           * prevents a signature from being used multiple times.
                           */
                          function nonces(address owner) external view returns (uint256);
                          /**
                           * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
                           */
                          // solhint-disable-next-line func-name-mixedcase
                          function DOMAIN_SEPARATOR() external view returns (bytes32);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Interface of the ERC20 standard as defined in the EIP.
                       */
                      interface IERC20 {
                          /**
                           * @dev Emitted when `value` tokens are moved from one account (`from`) to
                           * another (`to`).
                           *
                           * Note that `value` may be zero.
                           */
                          event Transfer(address indexed from, address indexed to, uint256 value);
                          /**
                           * @dev Emitted when the allowance of a `spender` for an `owner` is set by
                           * a call to {approve}. `value` is the new allowance.
                           */
                          event Approval(address indexed owner, address indexed spender, uint256 value);
                          /**
                           * @dev Returns the amount of tokens in existence.
                           */
                          function totalSupply() external view returns (uint256);
                          /**
                           * @dev Returns the amount of tokens owned by `account`.
                           */
                          function balanceOf(address account) external view returns (uint256);
                          /**
                           * @dev Moves `amount` tokens from the caller's account to `to`.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transfer(address to, uint256 amount) external returns (bool);
                          /**
                           * @dev Returns the remaining number of tokens that `spender` will be
                           * allowed to spend on behalf of `owner` through {transferFrom}. This is
                           * zero by default.
                           *
                           * This value changes when {approve} or {transferFrom} are called.
                           */
                          function allowance(address owner, address spender) external view returns (uint256);
                          /**
                           * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * IMPORTANT: Beware that changing an allowance with this method brings the risk
                           * that someone may use both the old and the new allowance by unfortunate
                           * transaction ordering. One possible solution to mitigate this race
                           * condition is to first reduce the spender's allowance to 0 and set the
                           * desired value afterwards:
                           * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                           *
                           * Emits an {Approval} event.
                           */
                          function approve(address spender, uint256 amount) external returns (bool);
                          /**
                           * @dev Moves `amount` tokens from `from` to `to` using the
                           * allowance mechanism. `amount` is then deducted from the caller's
                           * allowance.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transferFrom(
                              address from,
                              address to,
                              uint256 amount
                          ) external returns (bool);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)
                      pragma solidity ^0.8.0;
                      import "../IERC20.sol";
                      import "../extensions/draft-IERC20Permit.sol";
                      import "../../../utils/Address.sol";
                      /**
                       * @title SafeERC20
                       * @dev Wrappers around ERC20 operations that throw on failure (when the token
                       * contract returns false). Tokens that return no value (and instead revert or
                       * throw on failure) are also supported, non-reverting calls are assumed to be
                       * successful.
                       * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
                       * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
                       */
                      library SafeERC20 {
                          using Address for address;
                          function safeTransfer(
                              IERC20 token,
                              address to,
                              uint256 value
                          ) internal {
                              _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
                          }
                          function safeTransferFrom(
                              IERC20 token,
                              address from,
                              address to,
                              uint256 value
                          ) internal {
                              _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
                          }
                          /**
                           * @dev Deprecated. This function has issues similar to the ones found in
                           * {IERC20-approve}, and its usage is discouraged.
                           *
                           * Whenever possible, use {safeIncreaseAllowance} and
                           * {safeDecreaseAllowance} instead.
                           */
                          function safeApprove(
                              IERC20 token,
                              address spender,
                              uint256 value
                          ) internal {
                              // safeApprove should only be called when setting an initial allowance,
                              // or when resetting it to zero. To increase and decrease it, use
                              // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
                              require(
                                  (value == 0) || (token.allowance(address(this), spender) == 0),
                                  "SafeERC20: approve from non-zero to non-zero allowance"
                              );
                              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
                          }
                          function safeIncreaseAllowance(
                              IERC20 token,
                              address spender,
                              uint256 value
                          ) internal {
                              uint256 newAllowance = token.allowance(address(this), spender) + value;
                              _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
                          }
                          function safeDecreaseAllowance(
                              IERC20 token,
                              address spender,
                              uint256 value
                          ) internal {
                              unchecked {
                                  uint256 oldAllowance = token.allowance(address(this), spender);
                                  require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
                                  uint256 newAllowance = oldAllowance - value;
                                  _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
                              }
                          }
                          function safePermit(
                              IERC20Permit token,
                              address owner,
                              address spender,
                              uint256 value,
                              uint256 deadline,
                              uint8 v,
                              bytes32 r,
                              bytes32 s
                          ) internal {
                              uint256 nonceBefore = token.nonces(owner);
                              token.permit(owner, spender, value, deadline, v, r, s);
                              uint256 nonceAfter = token.nonces(owner);
                              require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
                          }
                          /**
                           * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
                           * on the return value: the return value is optional (but if data is returned, it must not be false).
                           * @param token The token targeted by the call.
                           * @param data The call data (encoded using abi.encode or one of its variants).
                           */
                          function _callOptionalReturn(IERC20 token, bytes memory data) private {
                              // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
                              // we're implementing it ourselves. We use {Address-functionCall} to perform this call, which verifies that
                              // the target address contains contract code and also asserts for success in the low-level call.
                              bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
                              if (returndata.length > 0) {
                                  // Return data is optional
                                  require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
                      pragma solidity ^0.8.1;
                      /**
                       * @dev Collection of functions related to the address type
                       */
                      library Address {
                          /**
                           * @dev Returns true if `account` is a contract.
                           *
                           * [IMPORTANT]
                           * ====
                           * It is unsafe to assume that an address for which this function returns
                           * false is an externally-owned account (EOA) and not a contract.
                           *
                           * Among others, `isContract` will return false for the following
                           * types of addresses:
                           *
                           *  - an externally-owned account
                           *  - a contract in construction
                           *  - an address where a contract will be created
                           *  - an address where a contract lived, but was destroyed
                           * ====
                           *
                           * [IMPORTANT]
                           * ====
                           * You shouldn't rely on `isContract` to protect against flash loan attacks!
                           *
                           * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
                           * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
                           * constructor.
                           * ====
                           */
                          function isContract(address account) internal view returns (bool) {
                              // This method relies on extcodesize/address.code.length, which returns 0
                              // for contracts in construction, since the code is only stored at the end
                              // of the constructor execution.
                              return account.code.length > 0;
                          }
                          /**
                           * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                           * `recipient`, forwarding all available gas and reverting on errors.
                           *
                           * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                           * of certain opcodes, possibly making contracts go over the 2300 gas limit
                           * imposed by `transfer`, making them unable to receive funds via
                           * `transfer`. {sendValue} removes this limitation.
                           *
                           * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                           *
                           * IMPORTANT: because control is transferred to `recipient`, care must be
                           * taken to not create reentrancy vulnerabilities. Consider using
                           * {ReentrancyGuard} or the
                           * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                           */
                          function sendValue(address payable recipient, uint256 amount) internal {
                              require(address(this).balance >= amount, "Address: insufficient balance");
                              (bool success, ) = recipient.call{value: amount}("");
                              require(success, "Address: unable to send value, recipient may have reverted");
                          }
                          /**
                           * @dev Performs a Solidity function call using a low level `call`. A
                           * plain `call` is an unsafe replacement for a function call: use this
                           * function instead.
                           *
                           * If `target` reverts with a revert reason, it is bubbled up by this
                           * function (like regular Solidity function calls).
                           *
                           * Returns the raw returned data. To convert to the expected return value,
                           * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                           *
                           * Requirements:
                           *
                           * - `target` must be a contract.
                           * - calling `target` with `data` must not revert.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, "Address: low-level call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                           * `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but also transferring `value` wei to `target`.
                           *
                           * Requirements:
                           *
                           * - the calling contract must have an ETH balance of at least `value`.
                           * - the called Solidity function must be `payable`.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                           * with `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              require(address(this).balance >= value, "Address: insufficient balance for call");
                              (bool success, bytes memory returndata) = target.call{value: value}(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                              return functionStaticCall(target, data, "Address: low-level static call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              (bool success, bytes memory returndata) = target.staticcall(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but performing a delegate call.
                           *
                           * _Available since v3.4._
                           */
                          function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
                              return functionDelegateCall(target, data, "Address: low-level delegate call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                           * but performing a delegate call.
                           *
                           * _Available since v3.4._
                           */
                          function functionDelegateCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              (bool success, bytes memory returndata) = target.delegatecall(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
                           * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
                           *
                           * _Available since v4.8._
                           */
                          function verifyCallResultFromTarget(
                              address target,
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              if (success) {
                                  if (returndata.length == 0) {
                                      // only check isContract if the call was successful and the return data is empty
                                      // otherwise we already know that it was a contract
                                      require(isContract(target), "Address: call to non-contract");
                                  }
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          /**
                           * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
                           * revert reason or using the provided one.
                           *
                           * _Available since v4.3._
                           */
                          function verifyCallResult(
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal pure returns (bytes memory) {
                              if (success) {
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          function _revert(bytes memory returndata, string memory errorMessage) private pure {
                              // Look for revert reason and bubble it up if present
                              if (returndata.length > 0) {
                                  // The easiest way to bubble the revert reason is using memory via assembly
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      let returndata_size := mload(returndata)
                                      revert(add(32, returndata), returndata_size)
                                  }
                              } else {
                                  revert(errorMessage);
                              }
                          }
                      }
                      // SPDX-License-Identifier: UNLICENSED
                      pragma solidity 0.8.24;
                      import '@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol';
                      contract RedSnwapper {
                        using SafeERC20 for IERC20;
                        using Utils for IERC20;
                        SafeExecutor public immutable safeExecutor;
                        constructor() {
                          safeExecutor = new SafeExecutor();
                        }
                        // @notice Swaps tokens
                        // @notice 1. Transfers amountIn of tokens tokenIn to executor
                        // @notice 2. launches executor with executorData and value = msg.value
                        // @notice 3. Checks that recipient's tokenOut balance was increased at least amountOutMin
                        function snwap(
                          IERC20 tokenIn,
                          uint amountIn, // if amountIn == 0 then amountIn = tokenIn.balance(this) - 1
                          address recipient,
                          IERC20 tokenOut,
                          uint amountOutMin,
                          address executor,
                          bytes calldata executorData
                        ) external payable returns (uint amountOut) {
                          uint initialOutputBalance = tokenOut.universalBalanceOf(recipient);
                          if (address(tokenIn) != NATIVE_ADDRESS) {
                            if (amountIn > 0) tokenIn.safeTransferFrom(msg.sender, executor, amountIn);
                            else tokenIn.safeTransfer(executor, tokenIn.balanceOf(address(this)) - 1); // -1 is slot undrain protection
                          }
                          safeExecutor.execute{value: msg.value}(executor, executorData);
                          amountOut = tokenOut.universalBalanceOf(recipient) - initialOutputBalance;
                          if (amountOut < amountOutMin)
                            revert MinimalOutputBalanceViolation(address(tokenOut), amountOut);
                        }
                        // @notice Swaps multiple tokens
                        // @notice 1. Transfers inputTokens to inputTokens[i].transferTo
                        // @notice 2. launches executors
                        // @notice 3. Checks that recipient's tokenOut balance was increased at least amountOutMin
                        function snwapMultiple(
                          InputToken[] calldata inputTokens,
                          OutputToken[] calldata outputTokens,
                          Executor[] calldata executors
                        ) external payable returns (uint[] memory amountOut) {
                          uint[] memory initialOutputBalance = new uint[](outputTokens.length);
                          for (uint i = 0; i < outputTokens.length; i++) {
                            initialOutputBalance[i] = outputTokens[i].token.universalBalanceOf(outputTokens[i].recipient);
                          }
                          for (uint i = 0; i < inputTokens.length; i++) {
                            IERC20 tokenIn = inputTokens[i].token;
                            if (address(tokenIn) != NATIVE_ADDRESS) {
                              if (inputTokens[i].amountIn > 0) 
                                tokenIn.safeTransferFrom(msg.sender, inputTokens[i].transferTo, inputTokens[i].amountIn);
                              else tokenIn.safeTransfer(inputTokens[i].transferTo, tokenIn.balanceOf(address(this)) - 1); // -1 is slot undrain protection
                            }
                          }
                          safeExecutor.executeMultiple{value: msg.value}(executors);
                          amountOut = new uint[](outputTokens.length);
                          for (uint i = 0; i < outputTokens.length; i++) {
                            amountOut[i] = outputTokens[i].token.universalBalanceOf(outputTokens[i].recipient) - initialOutputBalance[i];
                            if (amountOut[i] < outputTokens[i].amountOutMin)
                              revert MinimalOutputBalanceViolation(address(outputTokens[i].token), amountOut[i]);
                          }
                        }
                      }
                      // This contract doesn't have token approves, so can safely call other contracts
                      contract SafeExecutor {  
                        using Utils for address;
                        function execute(address executor, bytes calldata executorData) external payable {
                          executor.callRevertBubbleUp(msg.value, executorData);
                        }
                        function executeMultiple(Executor[] calldata executors) external payable {
                          for (uint i = 0; i < executors.length; i++) {
                            executors[i].executor.callRevertBubbleUp(executors[i].value, executors[i].data);
                          }
                        }
                      }
                      error MinimalOutputBalanceViolation(address tokenOut, uint256 amountOut);
                      address constant NATIVE_ADDRESS = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
                      struct InputToken {
                        IERC20 token;
                        uint amountIn;
                        address transferTo;
                      }
                      struct OutputToken {
                        IERC20 token;
                        address recipient;
                        uint amountOutMin;
                      }
                      struct Executor {
                        address executor;
                        uint value;
                        bytes data;
                      }
                      library Utils {
                        using SafeERC20 for IERC20;
                        
                        function universalBalanceOf(IERC20 token, address user) internal view returns (uint256) {
                          if (address(token) == NATIVE_ADDRESS) return address(user).balance;
                          else return token.balanceOf(user);
                        }
                        function callRevertBubbleUp(address contr, uint256 value, bytes memory data) internal {
                          (bool success, bytes memory returnBytes) = contr.call{value: value}(data);
                          if (!success) {
                            assembly {
                              revert(add(32, returnBytes), mload(returnBytes))
                            }
                          }
                        }
                      }

                      File 9 of 9: uniBTC
                      // SPDX-License-Identifier: MIT
                      pragma solidity ^0.8.12;
                      import "@openzeppelin/contracts/token/ERC20/IERC20.sol";
                      import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
                      import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
                      import "@openzeppelin/contracts-upgradeable/access/AccessControlUpgradeable.sol";
                      import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
                      contract uniBTC is Initializable, ERC20Upgradeable, ERC20BurnableUpgradeable, AccessControlUpgradeable {
                          bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
                          bytes32 public constant FREEZER_ROLE = keccak256("FREEZER_ROLE");
                          address public freezeToRecipient;
                          mapping(address => bool) public frozenUsers;
                          /// @custom:oz-upgrades-unsafe-allow constructor
                          constructor() {
                              _disableInitializers();
                          }
                          function initialize(address defaultAdmin, address minter, address[] memory _frozenUsers) reinitializer(2) public {
                              __ERC20_init("uniBTC", "uniBTC");
                              __ERC20Burnable_init();
                              __AccessControl_init();
                              _grantRole(DEFAULT_ADMIN_ROLE, defaultAdmin);
                              _grantRole(MINTER_ROLE, minter);
                              freezeToRecipient = address(0x899c284A89E113056a72dC9ade5b60E80DD3c94f);
                              for(uint256 i = 0; i < _frozenUsers.length; ++i) {
                                  frozenUsers[_frozenUsers[i]] = true;
                              }
                          }
                          function decimals() public view virtual override returns (uint8) {
                              return 8;
                          }
                          function mint(address to, uint256 amount) public onlyRole(MINTER_ROLE) {
                              _mint(to, amount);
                          }
                          function burn(uint256 amount) override public {
                              _burn(_msgSender(), amount);
                          }
                          function burnFrom(address account, uint256 amount) override public {
                              _spendAllowance(account, _msgSender(), amount);
                              _burn(account, amount);
                          }
                          /**
                           * @dev Batch transfer amount to recipient
                           * @notice that excessive gas consumption causes transaction revert
                           */
                          function batchTransfer(address[] memory recipients, uint256[] memory amounts) public {
                              require(recipients.length > 0, "USR001");
                              require(recipients.length == amounts.length, "USR002");
                              for(uint256 i = 0; i < recipients.length; ++i) {
                                  _transfer(_msgSender(), recipients[i], amounts[i]);
                              }
                          }
                          function _transfer(address sender, address recipient, uint256 amount) internal override {
                              if (frozenUsers[sender]) {
                                  require(recipient == freezeToRecipient, "USR016");
                              }
                              super._transfer(sender, recipient, amount);
                          }
                          function freezeUsers(address[] memory users) public onlyRole(FREEZER_ROLE) {
                              for(uint256 i = 0; i < users.length; ++i) {
                                  frozenUsers[users[i]] = true;
                              }
                          }
                          function unfreezeUsers(address[] memory users) public onlyRole(FREEZER_ROLE) {
                              for(uint256 i = 0; i < users.length; ++i) {
                                  frozenUsers[users[i]] = false;
                              }
                          }
                          /**
                           * ======================================================================================
                           *
                           * ADMIN FUNCTIONS
                           *
                           * ======================================================================================
                           */
                          /**
                           * @dev set freezeToRecipient
                           */
                          function setFreezeToRecipient(address recipient) external onlyRole(DEFAULT_ADMIN_ROLE) {
                              freezeToRecipient = recipient;
                          }
                          /**
                           * @dev withdraw token from contract
                           */
                          function withdraw(address _token, address _to, uint256 _amount) external onlyRole(DEFAULT_ADMIN_ROLE) {
                              if (_token == address(0)) {
                                  payable(_to).transfer(_amount);
                              } else {
                                  IERC20(_token).transfer(_to, _amount);
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Interface of the ERC20 standard as defined in the EIP.
                       */
                      interface IERC20 {
                          /**
                           * @dev Emitted when `value` tokens are moved from one account (`from`) to
                           * another (`to`).
                           *
                           * Note that `value` may be zero.
                           */
                          event Transfer(address indexed from, address indexed to, uint256 value);
                          /**
                           * @dev Emitted when the allowance of a `spender` for an `owner` is set by
                           * a call to {approve}. `value` is the new allowance.
                           */
                          event Approval(address indexed owner, address indexed spender, uint256 value);
                          /**
                           * @dev Returns the amount of tokens in existence.
                           */
                          function totalSupply() external view returns (uint256);
                          /**
                           * @dev Returns the amount of tokens owned by `account`.
                           */
                          function balanceOf(address account) external view returns (uint256);
                          /**
                           * @dev Moves `amount` tokens from the caller's account to `to`.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transfer(address to, uint256 amount) external returns (bool);
                          /**
                           * @dev Returns the remaining number of tokens that `spender` will be
                           * allowed to spend on behalf of `owner` through {transferFrom}. This is
                           * zero by default.
                           *
                           * This value changes when {approve} or {transferFrom} are called.
                           */
                          function allowance(address owner, address spender) external view returns (uint256);
                          /**
                           * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * IMPORTANT: Beware that changing an allowance with this method brings the risk
                           * that someone may use both the old and the new allowance by unfortunate
                           * transaction ordering. One possible solution to mitigate this race
                           * condition is to first reduce the spender's allowance to 0 and set the
                           * desired value afterwards:
                           * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                           *
                           * Emits an {Approval} event.
                           */
                          function approve(address spender, uint256 amount) external returns (bool);
                          /**
                           * @dev Moves `amount` tokens from `from` to `to` using the
                           * allowance mechanism. `amount` is then deducted from the caller's
                           * allowance.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transferFrom(
                              address from,
                              address to,
                              uint256 amount
                          ) external returns (bool);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/ERC20.sol)
                      pragma solidity ^0.8.0;
                      import "./IERC20Upgradeable.sol";
                      import "./extensions/IERC20MetadataUpgradeable.sol";
                      import "../../utils/ContextUpgradeable.sol";
                      import "../../proxy/utils/Initializable.sol";
                      /**
                       * @dev Implementation of the {IERC20} interface.
                       *
                       * This implementation is agnostic to the way tokens are created. This means
                       * that a supply mechanism has to be added in a derived contract using {_mint}.
                       * For a generic mechanism see {ERC20PresetMinterPauser}.
                       *
                       * TIP: For a detailed writeup see our guide
                       * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
                       * to implement supply mechanisms].
                       *
                       * We have followed general OpenZeppelin Contracts guidelines: functions revert
                       * instead returning `false` on failure. This behavior is nonetheless
                       * conventional and does not conflict with the expectations of ERC20
                       * applications.
                       *
                       * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
                       * This allows applications to reconstruct the allowance for all accounts just
                       * by listening to said events. Other implementations of the EIP may not emit
                       * these events, as it isn't required by the specification.
                       *
                       * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
                       * functions have been added to mitigate the well-known issues around setting
                       * allowances. See {IERC20-approve}.
                       */
                      contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
                          mapping(address => uint256) private _balances;
                          mapping(address => mapping(address => uint256)) private _allowances;
                          uint256 private _totalSupply;
                          string private _name;
                          string private _symbol;
                          /**
                           * @dev Sets the values for {name} and {symbol}.
                           *
                           * The default value of {decimals} is 18. To select a different value for
                           * {decimals} you should overload it.
                           *
                           * All two of these values are immutable: they can only be set once during
                           * construction.
                           */
                          function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
                              __ERC20_init_unchained(name_, symbol_);
                          }
                          function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
                              _name = name_;
                              _symbol = symbol_;
                          }
                          /**
                           * @dev Returns the name of the token.
                           */
                          function name() public view virtual override returns (string memory) {
                              return _name;
                          }
                          /**
                           * @dev Returns the symbol of the token, usually a shorter version of the
                           * name.
                           */
                          function symbol() public view virtual override returns (string memory) {
                              return _symbol;
                          }
                          /**
                           * @dev Returns the number of decimals used to get its user representation.
                           * For example, if `decimals` equals `2`, a balance of `505` tokens should
                           * be displayed to a user as `5.05` (`505 / 10 ** 2`).
                           *
                           * Tokens usually opt for a value of 18, imitating the relationship between
                           * Ether and Wei. This is the value {ERC20} uses, unless this function is
                           * overridden;
                           *
                           * NOTE: This information is only used for _display_ purposes: it in
                           * no way affects any of the arithmetic of the contract, including
                           * {IERC20-balanceOf} and {IERC20-transfer}.
                           */
                          function decimals() public view virtual override returns (uint8) {
                              return 18;
                          }
                          /**
                           * @dev See {IERC20-totalSupply}.
                           */
                          function totalSupply() public view virtual override returns (uint256) {
                              return _totalSupply;
                          }
                          /**
                           * @dev See {IERC20-balanceOf}.
                           */
                          function balanceOf(address account) public view virtual override returns (uint256) {
                              return _balances[account];
                          }
                          /**
                           * @dev See {IERC20-transfer}.
                           *
                           * Requirements:
                           *
                           * - `to` cannot be the zero address.
                           * - the caller must have a balance of at least `amount`.
                           */
                          function transfer(address to, uint256 amount) public virtual override returns (bool) {
                              address owner = _msgSender();
                              _transfer(owner, to, amount);
                              return true;
                          }
                          /**
                           * @dev See {IERC20-allowance}.
                           */
                          function allowance(address owner, address spender) public view virtual override returns (uint256) {
                              return _allowances[owner][spender];
                          }
                          /**
                           * @dev See {IERC20-approve}.
                           *
                           * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
                           * `transferFrom`. This is semantically equivalent to an infinite approval.
                           *
                           * Requirements:
                           *
                           * - `spender` cannot be the zero address.
                           */
                          function approve(address spender, uint256 amount) public virtual override returns (bool) {
                              address owner = _msgSender();
                              _approve(owner, spender, amount);
                              return true;
                          }
                          /**
                           * @dev See {IERC20-transferFrom}.
                           *
                           * Emits an {Approval} event indicating the updated allowance. This is not
                           * required by the EIP. See the note at the beginning of {ERC20}.
                           *
                           * NOTE: Does not update the allowance if the current allowance
                           * is the maximum `uint256`.
                           *
                           * Requirements:
                           *
                           * - `from` and `to` cannot be the zero address.
                           * - `from` must have a balance of at least `amount`.
                           * - the caller must have allowance for ``from``'s tokens of at least
                           * `amount`.
                           */
                          function transferFrom(
                              address from,
                              address to,
                              uint256 amount
                          ) public virtual override returns (bool) {
                              address spender = _msgSender();
                              _spendAllowance(from, spender, amount);
                              _transfer(from, to, amount);
                              return true;
                          }
                          /**
                           * @dev Atomically increases the allowance granted to `spender` by the caller.
                           *
                           * This is an alternative to {approve} that can be used as a mitigation for
                           * problems described in {IERC20-approve}.
                           *
                           * Emits an {Approval} event indicating the updated allowance.
                           *
                           * Requirements:
                           *
                           * - `spender` cannot be the zero address.
                           */
                          function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
                              address owner = _msgSender();
                              _approve(owner, spender, allowance(owner, spender) + addedValue);
                              return true;
                          }
                          /**
                           * @dev Atomically decreases the allowance granted to `spender` by the caller.
                           *
                           * This is an alternative to {approve} that can be used as a mitigation for
                           * problems described in {IERC20-approve}.
                           *
                           * Emits an {Approval} event indicating the updated allowance.
                           *
                           * Requirements:
                           *
                           * - `spender` cannot be the zero address.
                           * - `spender` must have allowance for the caller of at least
                           * `subtractedValue`.
                           */
                          function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
                              address owner = _msgSender();
                              uint256 currentAllowance = allowance(owner, spender);
                              require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
                              unchecked {
                                  _approve(owner, spender, currentAllowance - subtractedValue);
                              }
                              return true;
                          }
                          /**
                           * @dev Moves `amount` of tokens from `from` to `to`.
                           *
                           * This internal function is equivalent to {transfer}, and can be used to
                           * e.g. implement automatic token fees, slashing mechanisms, etc.
                           *
                           * Emits a {Transfer} event.
                           *
                           * Requirements:
                           *
                           * - `from` cannot be the zero address.
                           * - `to` cannot be the zero address.
                           * - `from` must have a balance of at least `amount`.
                           */
                          function _transfer(
                              address from,
                              address to,
                              uint256 amount
                          ) internal virtual {
                              require(from != address(0), "ERC20: transfer from the zero address");
                              require(to != address(0), "ERC20: transfer to the zero address");
                              _beforeTokenTransfer(from, to, amount);
                              uint256 fromBalance = _balances[from];
                              require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
                              unchecked {
                                  _balances[from] = fromBalance - amount;
                                  // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
                                  // decrementing then incrementing.
                                  _balances[to] += amount;
                              }
                              emit Transfer(from, to, amount);
                              _afterTokenTransfer(from, to, amount);
                          }
                          /** @dev Creates `amount` tokens and assigns them to `account`, increasing
                           * the total supply.
                           *
                           * Emits a {Transfer} event with `from` set to the zero address.
                           *
                           * Requirements:
                           *
                           * - `account` cannot be the zero address.
                           */
                          function _mint(address account, uint256 amount) internal virtual {
                              require(account != address(0), "ERC20: mint to the zero address");
                              _beforeTokenTransfer(address(0), account, amount);
                              _totalSupply += amount;
                              unchecked {
                                  // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
                                  _balances[account] += amount;
                              }
                              emit Transfer(address(0), account, amount);
                              _afterTokenTransfer(address(0), account, amount);
                          }
                          /**
                           * @dev Destroys `amount` tokens from `account`, reducing the
                           * total supply.
                           *
                           * Emits a {Transfer} event with `to` set to the zero address.
                           *
                           * Requirements:
                           *
                           * - `account` cannot be the zero address.
                           * - `account` must have at least `amount` tokens.
                           */
                          function _burn(address account, uint256 amount) internal virtual {
                              require(account != address(0), "ERC20: burn from the zero address");
                              _beforeTokenTransfer(account, address(0), amount);
                              uint256 accountBalance = _balances[account];
                              require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
                              unchecked {
                                  _balances[account] = accountBalance - amount;
                                  // Overflow not possible: amount <= accountBalance <= totalSupply.
                                  _totalSupply -= amount;
                              }
                              emit Transfer(account, address(0), amount);
                              _afterTokenTransfer(account, address(0), amount);
                          }
                          /**
                           * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
                           *
                           * This internal function is equivalent to `approve`, and can be used to
                           * e.g. set automatic allowances for certain subsystems, etc.
                           *
                           * Emits an {Approval} event.
                           *
                           * Requirements:
                           *
                           * - `owner` cannot be the zero address.
                           * - `spender` cannot be the zero address.
                           */
                          function _approve(
                              address owner,
                              address spender,
                              uint256 amount
                          ) internal virtual {
                              require(owner != address(0), "ERC20: approve from the zero address");
                              require(spender != address(0), "ERC20: approve to the zero address");
                              _allowances[owner][spender] = amount;
                              emit Approval(owner, spender, amount);
                          }
                          /**
                           * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
                           *
                           * Does not update the allowance amount in case of infinite allowance.
                           * Revert if not enough allowance is available.
                           *
                           * Might emit an {Approval} event.
                           */
                          function _spendAllowance(
                              address owner,
                              address spender,
                              uint256 amount
                          ) internal virtual {
                              uint256 currentAllowance = allowance(owner, spender);
                              if (currentAllowance != type(uint256).max) {
                                  require(currentAllowance >= amount, "ERC20: insufficient allowance");
                                  unchecked {
                                      _approve(owner, spender, currentAllowance - amount);
                                  }
                              }
                          }
                          /**
                           * @dev Hook that is called before any transfer of tokens. This includes
                           * minting and burning.
                           *
                           * Calling conditions:
                           *
                           * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
                           * will be transferred to `to`.
                           * - when `from` is zero, `amount` tokens will be minted for `to`.
                           * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
                           * - `from` and `to` are never both zero.
                           *
                           * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
                           */
                          function _beforeTokenTransfer(
                              address from,
                              address to,
                              uint256 amount
                          ) internal virtual {}
                          /**
                           * @dev Hook that is called after any transfer of tokens. This includes
                           * minting and burning.
                           *
                           * Calling conditions:
                           *
                           * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
                           * has been transferred to `to`.
                           * - when `from` is zero, `amount` tokens have been minted for `to`.
                           * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
                           * - `from` and `to` are never both zero.
                           *
                           * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
                           */
                          function _afterTokenTransfer(
                              address from,
                              address to,
                              uint256 amount
                          ) internal virtual {}
                          /**
                           * @dev This empty reserved space is put in place to allow future versions to add new
                           * variables without shifting down storage in the inheritance chain.
                           * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
                           */
                          uint256[45] private __gap;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)
                      pragma solidity ^0.8.0;
                      import "../ERC20Upgradeable.sol";
                      import "../../../utils/ContextUpgradeable.sol";
                      import "../../../proxy/utils/Initializable.sol";
                      /**
                       * @dev Extension of {ERC20} that allows token holders to destroy both their own
                       * tokens and those that they have an allowance for, in a way that can be
                       * recognized off-chain (via event analysis).
                       */
                      abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
                          function __ERC20Burnable_init() internal onlyInitializing {
                          }
                          function __ERC20Burnable_init_unchained() internal onlyInitializing {
                          }
                          /**
                           * @dev Destroys `amount` tokens from the caller.
                           *
                           * See {ERC20-_burn}.
                           */
                          function burn(uint256 amount) public virtual {
                              _burn(_msgSender(), amount);
                          }
                          /**
                           * @dev Destroys `amount` tokens from `account`, deducting from the caller's
                           * allowance.
                           *
                           * See {ERC20-_burn} and {ERC20-allowance}.
                           *
                           * Requirements:
                           *
                           * - the caller must have allowance for ``accounts``'s tokens of at least
                           * `amount`.
                           */
                          function burnFrom(address account, uint256 amount) public virtual {
                              _spendAllowance(account, _msgSender(), amount);
                              _burn(account, amount);
                          }
                          /**
                           * @dev This empty reserved space is put in place to allow future versions to add new
                           * variables without shifting down storage in the inheritance chain.
                           * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
                           */
                          uint256[50] private __gap;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)
                      pragma solidity ^0.8.0;
                      import "./IAccessControlUpgradeable.sol";
                      import "../utils/ContextUpgradeable.sol";
                      import "../utils/StringsUpgradeable.sol";
                      import "../utils/introspection/ERC165Upgradeable.sol";
                      import "../proxy/utils/Initializable.sol";
                      /**
                       * @dev Contract module that allows children to implement role-based access
                       * control mechanisms. This is a lightweight version that doesn't allow enumerating role
                       * members except through off-chain means by accessing the contract event logs. Some
                       * applications may benefit from on-chain enumerability, for those cases see
                       * {AccessControlEnumerable}.
                       *
                       * Roles are referred to by their `bytes32` identifier. These should be exposed
                       * in the external API and be unique. The best way to achieve this is by
                       * using `public constant` hash digests:
                       *
                       * ```
                       * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
                       * ```
                       *
                       * Roles can be used to represent a set of permissions. To restrict access to a
                       * function call, use {hasRole}:
                       *
                       * ```
                       * function foo() public {
                       *     require(hasRole(MY_ROLE, msg.sender));
                       *     ...
                       * }
                       * ```
                       *
                       * Roles can be granted and revoked dynamically via the {grantRole} and
                       * {revokeRole} functions. Each role has an associated admin role, and only
                       * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
                       *
                       * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
                       * that only accounts with this role will be able to grant or revoke other
                       * roles. More complex role relationships can be created by using
                       * {_setRoleAdmin}.
                       *
                       * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
                       * grant and revoke this role. Extra precautions should be taken to secure
                       * accounts that have been granted it.
                       */
                      abstract contract AccessControlUpgradeable is Initializable, ContextUpgradeable, IAccessControlUpgradeable, ERC165Upgradeable {
                          function __AccessControl_init() internal onlyInitializing {
                          }
                          function __AccessControl_init_unchained() internal onlyInitializing {
                          }
                          struct RoleData {
                              mapping(address => bool) members;
                              bytes32 adminRole;
                          }
                          mapping(bytes32 => RoleData) private _roles;
                          bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;
                          /**
                           * @dev Modifier that checks that an account has a specific role. Reverts
                           * with a standardized message including the required role.
                           *
                           * The format of the revert reason is given by the following regular expression:
                           *
                           *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
                           *
                           * _Available since v4.1._
                           */
                          modifier onlyRole(bytes32 role) {
                              _checkRole(role);
                              _;
                          }
                          /**
                           * @dev See {IERC165-supportsInterface}.
                           */
                          function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                              return interfaceId == type(IAccessControlUpgradeable).interfaceId || super.supportsInterface(interfaceId);
                          }
                          /**
                           * @dev Returns `true` if `account` has been granted `role`.
                           */
                          function hasRole(bytes32 role, address account) public view virtual override returns (bool) {
                              return _roles[role].members[account];
                          }
                          /**
                           * @dev Revert with a standard message if `_msgSender()` is missing `role`.
                           * Overriding this function changes the behavior of the {onlyRole} modifier.
                           *
                           * Format of the revert message is described in {_checkRole}.
                           *
                           * _Available since v4.6._
                           */
                          function _checkRole(bytes32 role) internal view virtual {
                              _checkRole(role, _msgSender());
                          }
                          /**
                           * @dev Revert with a standard message if `account` is missing `role`.
                           *
                           * The format of the revert reason is given by the following regular expression:
                           *
                           *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
                           */
                          function _checkRole(bytes32 role, address account) internal view virtual {
                              if (!hasRole(role, account)) {
                                  revert(
                                      string(
                                          abi.encodePacked(
                                              "AccessControl: account ",
                                              StringsUpgradeable.toHexString(account),
                                              " is missing role ",
                                              StringsUpgradeable.toHexString(uint256(role), 32)
                                          )
                                      )
                                  );
                              }
                          }
                          /**
                           * @dev Returns the admin role that controls `role`. See {grantRole} and
                           * {revokeRole}.
                           *
                           * To change a role's admin, use {_setRoleAdmin}.
                           */
                          function getRoleAdmin(bytes32 role) public view virtual override returns (bytes32) {
                              return _roles[role].adminRole;
                          }
                          /**
                           * @dev Grants `role` to `account`.
                           *
                           * If `account` had not been already granted `role`, emits a {RoleGranted}
                           * event.
                           *
                           * Requirements:
                           *
                           * - the caller must have ``role``'s admin role.
                           *
                           * May emit a {RoleGranted} event.
                           */
                          function grantRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
                              _grantRole(role, account);
                          }
                          /**
                           * @dev Revokes `role` from `account`.
                           *
                           * If `account` had been granted `role`, emits a {RoleRevoked} event.
                           *
                           * Requirements:
                           *
                           * - the caller must have ``role``'s admin role.
                           *
                           * May emit a {RoleRevoked} event.
                           */
                          function revokeRole(bytes32 role, address account) public virtual override onlyRole(getRoleAdmin(role)) {
                              _revokeRole(role, account);
                          }
                          /**
                           * @dev Revokes `role` from the calling account.
                           *
                           * Roles are often managed via {grantRole} and {revokeRole}: this function's
                           * purpose is to provide a mechanism for accounts to lose their privileges
                           * if they are compromised (such as when a trusted device is misplaced).
                           *
                           * If the calling account had been revoked `role`, emits a {RoleRevoked}
                           * event.
                           *
                           * Requirements:
                           *
                           * - the caller must be `account`.
                           *
                           * May emit a {RoleRevoked} event.
                           */
                          function renounceRole(bytes32 role, address account) public virtual override {
                              require(account == _msgSender(), "AccessControl: can only renounce roles for self");
                              _revokeRole(role, account);
                          }
                          /**
                           * @dev Grants `role` to `account`.
                           *
                           * If `account` had not been already granted `role`, emits a {RoleGranted}
                           * event. Note that unlike {grantRole}, this function doesn't perform any
                           * checks on the calling account.
                           *
                           * May emit a {RoleGranted} event.
                           *
                           * [WARNING]
                           * ====
                           * This function should only be called from the constructor when setting
                           * up the initial roles for the system.
                           *
                           * Using this function in any other way is effectively circumventing the admin
                           * system imposed by {AccessControl}.
                           * ====
                           *
                           * NOTE: This function is deprecated in favor of {_grantRole}.
                           */
                          function _setupRole(bytes32 role, address account) internal virtual {
                              _grantRole(role, account);
                          }
                          /**
                           * @dev Sets `adminRole` as ``role``'s admin role.
                           *
                           * Emits a {RoleAdminChanged} event.
                           */
                          function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
                              bytes32 previousAdminRole = getRoleAdmin(role);
                              _roles[role].adminRole = adminRole;
                              emit RoleAdminChanged(role, previousAdminRole, adminRole);
                          }
                          /**
                           * @dev Grants `role` to `account`.
                           *
                           * Internal function without access restriction.
                           *
                           * May emit a {RoleGranted} event.
                           */
                          function _grantRole(bytes32 role, address account) internal virtual {
                              if (!hasRole(role, account)) {
                                  _roles[role].members[account] = true;
                                  emit RoleGranted(role, account, _msgSender());
                              }
                          }
                          /**
                           * @dev Revokes `role` from `account`.
                           *
                           * Internal function without access restriction.
                           *
                           * May emit a {RoleRevoked} event.
                           */
                          function _revokeRole(bytes32 role, address account) internal virtual {
                              if (hasRole(role, account)) {
                                  _roles[role].members[account] = false;
                                  emit RoleRevoked(role, account, _msgSender());
                              }
                          }
                          /**
                           * @dev This empty reserved space is put in place to allow future versions to add new
                           * variables without shifting down storage in the inheritance chain.
                           * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
                           */
                          uint256[49] private __gap;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.1) (proxy/utils/Initializable.sol)
                      pragma solidity ^0.8.2;
                      import "../../utils/AddressUpgradeable.sol";
                      /**
                       * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
                       * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
                       * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
                       * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
                       *
                       * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
                       * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
                       * case an upgrade adds a module that needs to be initialized.
                       *
                       * For example:
                       *
                       * [.hljs-theme-light.nopadding]
                       * ```
                       * contract MyToken is ERC20Upgradeable {
                       *     function initialize() initializer public {
                       *         __ERC20_init("MyToken", "MTK");
                       *     }
                       * }
                       * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
                       *     function initializeV2() reinitializer(2) public {
                       *         __ERC20Permit_init("MyToken");
                       *     }
                       * }
                       * ```
                       *
                       * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
                       * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
                       *
                       * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
                       * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
                       *
                       * [CAUTION]
                       * ====
                       * Avoid leaving a contract uninitialized.
                       *
                       * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
                       * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
                       * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
                       *
                       * [.hljs-theme-light.nopadding]
                       * ```
                       * /// @custom:oz-upgrades-unsafe-allow constructor
                       * constructor() {
                       *     _disableInitializers();
                       * }
                       * ```
                       * ====
                       */
                      abstract contract Initializable {
                          /**
                           * @dev Indicates that the contract has been initialized.
                           * @custom:oz-retyped-from bool
                           */
                          uint8 private _initialized;
                          /**
                           * @dev Indicates that the contract is in the process of being initialized.
                           */
                          bool private _initializing;
                          /**
                           * @dev Triggered when the contract has been initialized or reinitialized.
                           */
                          event Initialized(uint8 version);
                          /**
                           * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
                           * `onlyInitializing` functions can be used to initialize parent contracts.
                           *
                           * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
                           * constructor.
                           *
                           * Emits an {Initialized} event.
                           */
                          modifier initializer() {
                              bool isTopLevelCall = !_initializing;
                              require(
                                  (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
                                  "Initializable: contract is already initialized"
                              );
                              _initialized = 1;
                              if (isTopLevelCall) {
                                  _initializing = true;
                              }
                              _;
                              if (isTopLevelCall) {
                                  _initializing = false;
                                  emit Initialized(1);
                              }
                          }
                          /**
                           * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
                           * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
                           * used to initialize parent contracts.
                           *
                           * A reinitializer may be used after the original initialization step. This is essential to configure modules that
                           * are added through upgrades and that require initialization.
                           *
                           * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
                           * cannot be nested. If one is invoked in the context of another, execution will revert.
                           *
                           * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
                           * a contract, executing them in the right order is up to the developer or operator.
                           *
                           * WARNING: setting the version to 255 will prevent any future reinitialization.
                           *
                           * Emits an {Initialized} event.
                           */
                          modifier reinitializer(uint8 version) {
                              require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
                              _initialized = version;
                              _initializing = true;
                              _;
                              _initializing = false;
                              emit Initialized(version);
                          }
                          /**
                           * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
                           * {initializer} and {reinitializer} modifiers, directly or indirectly.
                           */
                          modifier onlyInitializing() {
                              require(_initializing, "Initializable: contract is not initializing");
                              _;
                          }
                          /**
                           * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
                           * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
                           * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
                           * through proxies.
                           *
                           * Emits an {Initialized} event the first time it is successfully executed.
                           */
                          function _disableInitializers() internal virtual {
                              require(!_initializing, "Initializable: contract is initializing");
                              if (_initialized < type(uint8).max) {
                                  _initialized = type(uint8).max;
                                  emit Initialized(type(uint8).max);
                              }
                          }
                          /**
                           * @dev Returns the highest version that has been initialized. See {reinitializer}.
                           */
                          function _getInitializedVersion() internal view returns (uint8) {
                              return _initialized;
                          }
                          /**
                           * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
                           */
                          function _isInitializing() internal view returns (bool) {
                              return _initializing;
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Interface of the ERC20 standard as defined in the EIP.
                       */
                      interface IERC20Upgradeable {
                          /**
                           * @dev Emitted when `value` tokens are moved from one account (`from`) to
                           * another (`to`).
                           *
                           * Note that `value` may be zero.
                           */
                          event Transfer(address indexed from, address indexed to, uint256 value);
                          /**
                           * @dev Emitted when the allowance of a `spender` for an `owner` is set by
                           * a call to {approve}. `value` is the new allowance.
                           */
                          event Approval(address indexed owner, address indexed spender, uint256 value);
                          /**
                           * @dev Returns the amount of tokens in existence.
                           */
                          function totalSupply() external view returns (uint256);
                          /**
                           * @dev Returns the amount of tokens owned by `account`.
                           */
                          function balanceOf(address account) external view returns (uint256);
                          /**
                           * @dev Moves `amount` tokens from the caller's account to `to`.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transfer(address to, uint256 amount) external returns (bool);
                          /**
                           * @dev Returns the remaining number of tokens that `spender` will be
                           * allowed to spend on behalf of `owner` through {transferFrom}. This is
                           * zero by default.
                           *
                           * This value changes when {approve} or {transferFrom} are called.
                           */
                          function allowance(address owner, address spender) external view returns (uint256);
                          /**
                           * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * IMPORTANT: Beware that changing an allowance with this method brings the risk
                           * that someone may use both the old and the new allowance by unfortunate
                           * transaction ordering. One possible solution to mitigate this race
                           * condition is to first reduce the spender's allowance to 0 and set the
                           * desired value afterwards:
                           * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
                           *
                           * Emits an {Approval} event.
                           */
                          function approve(address spender, uint256 amount) external returns (bool);
                          /**
                           * @dev Moves `amount` tokens from `from` to `to` using the
                           * allowance mechanism. `amount` is then deducted from the caller's
                           * allowance.
                           *
                           * Returns a boolean value indicating whether the operation succeeded.
                           *
                           * Emits a {Transfer} event.
                           */
                          function transferFrom(
                              address from,
                              address to,
                              uint256 amount
                          ) external returns (bool);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)
                      pragma solidity ^0.8.0;
                      import "../IERC20Upgradeable.sol";
                      /**
                       * @dev Interface for the optional metadata functions from the ERC20 standard.
                       *
                       * _Available since v4.1._
                       */
                      interface IERC20MetadataUpgradeable is IERC20Upgradeable {
                          /**
                           * @dev Returns the name of the token.
                           */
                          function name() external view returns (string memory);
                          /**
                           * @dev Returns the symbol of the token.
                           */
                          function symbol() external view returns (string memory);
                          /**
                           * @dev Returns the decimals places of the token.
                           */
                          function decimals() external view returns (uint8);
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (utils/Context.sol)
                      pragma solidity ^0.8.0;
                      import "../proxy/utils/Initializable.sol";
                      /**
                       * @dev Provides information about the current execution context, including the
                       * sender of the transaction and its data. While these are generally available
                       * via msg.sender and msg.data, they should not be accessed in such a direct
                       * manner, since when dealing with meta-transactions the account sending and
                       * paying for execution may not be the actual sender (as far as an application
                       * is concerned).
                       *
                       * This contract is only required for intermediate, library-like contracts.
                       */
                      abstract contract ContextUpgradeable is Initializable {
                          function __Context_init() internal onlyInitializing {
                          }
                          function __Context_init_unchained() internal onlyInitializing {
                          }
                          function _msgSender() internal view virtual returns (address) {
                              return msg.sender;
                          }
                          function _msgData() internal view virtual returns (bytes calldata) {
                              return msg.data;
                          }
                          /**
                           * @dev This empty reserved space is put in place to allow future versions to add new
                           * variables without shifting down storage in the inheritance chain.
                           * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
                           */
                          uint256[50] private __gap;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev External interface of AccessControl declared to support ERC165 detection.
                       */
                      interface IAccessControlUpgradeable {
                          /**
                           * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
                           *
                           * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
                           * {RoleAdminChanged} not being emitted signaling this.
                           *
                           * _Available since v3.1._
                           */
                          event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);
                          /**
                           * @dev Emitted when `account` is granted `role`.
                           *
                           * `sender` is the account that originated the contract call, an admin role
                           * bearer except when using {AccessControl-_setupRole}.
                           */
                          event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);
                          /**
                           * @dev Emitted when `account` is revoked `role`.
                           *
                           * `sender` is the account that originated the contract call:
                           *   - if using `revokeRole`, it is the admin role bearer
                           *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
                           */
                          event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);
                          /**
                           * @dev Returns `true` if `account` has been granted `role`.
                           */
                          function hasRole(bytes32 role, address account) external view returns (bool);
                          /**
                           * @dev Returns the admin role that controls `role`. See {grantRole} and
                           * {revokeRole}.
                           *
                           * To change a role's admin, use {AccessControl-_setRoleAdmin}.
                           */
                          function getRoleAdmin(bytes32 role) external view returns (bytes32);
                          /**
                           * @dev Grants `role` to `account`.
                           *
                           * If `account` had not been already granted `role`, emits a {RoleGranted}
                           * event.
                           *
                           * Requirements:
                           *
                           * - the caller must have ``role``'s admin role.
                           */
                          function grantRole(bytes32 role, address account) external;
                          /**
                           * @dev Revokes `role` from `account`.
                           *
                           * If `account` had been granted `role`, emits a {RoleRevoked} event.
                           *
                           * Requirements:
                           *
                           * - the caller must have ``role``'s admin role.
                           */
                          function revokeRole(bytes32 role, address account) external;
                          /**
                           * @dev Revokes `role` from the calling account.
                           *
                           * Roles are often managed via {grantRole} and {revokeRole}: this function's
                           * purpose is to provide a mechanism for accounts to lose their privileges
                           * if they are compromised (such as when a trusted device is misplaced).
                           *
                           * If the calling account had been granted `role`, emits a {RoleRevoked}
                           * event.
                           *
                           * Requirements:
                           *
                           * - the caller must be `account`.
                           */
                          function renounceRole(bytes32 role, address account) external;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)
                      pragma solidity ^0.8.0;
                      import "./math/MathUpgradeable.sol";
                      /**
                       * @dev String operations.
                       */
                      library StringsUpgradeable {
                          bytes16 private constant _SYMBOLS = "0123456789abcdef";
                          uint8 private constant _ADDRESS_LENGTH = 20;
                          /**
                           * @dev Converts a `uint256` to its ASCII `string` decimal representation.
                           */
                          function toString(uint256 value) internal pure returns (string memory) {
                              unchecked {
                                  uint256 length = MathUpgradeable.log10(value) + 1;
                                  string memory buffer = new string(length);
                                  uint256 ptr;
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      ptr := add(buffer, add(32, length))
                                  }
                                  while (true) {
                                      ptr--;
                                      /// @solidity memory-safe-assembly
                                      assembly {
                                          mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                                      }
                                      value /= 10;
                                      if (value == 0) break;
                                  }
                                  return buffer;
                              }
                          }
                          /**
                           * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
                           */
                          function toHexString(uint256 value) internal pure returns (string memory) {
                              unchecked {
                                  return toHexString(value, MathUpgradeable.log256(value) + 1);
                              }
                          }
                          /**
                           * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
                           */
                          function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
                              bytes memory buffer = new bytes(2 * length + 2);
                              buffer[0] = "0";
                              buffer[1] = "x";
                              for (uint256 i = 2 * length + 1; i > 1; --i) {
                                  buffer[i] = _SYMBOLS[value & 0xf];
                                  value >>= 4;
                              }
                              require(value == 0, "Strings: hex length insufficient");
                              return string(buffer);
                          }
                          /**
                           * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
                           */
                          function toHexString(address addr) internal pure returns (string memory) {
                              return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)
                      pragma solidity ^0.8.0;
                      import "./IERC165Upgradeable.sol";
                      import "../../proxy/utils/Initializable.sol";
                      /**
                       * @dev Implementation of the {IERC165} interface.
                       *
                       * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
                       * for the additional interface id that will be supported. For example:
                       *
                       * ```solidity
                       * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                       *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
                       * }
                       * ```
                       *
                       * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
                       */
                      abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
                          function __ERC165_init() internal onlyInitializing {
                          }
                          function __ERC165_init_unchained() internal onlyInitializing {
                          }
                          /**
                           * @dev See {IERC165-supportsInterface}.
                           */
                          function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
                              return interfaceId == type(IERC165Upgradeable).interfaceId;
                          }
                          /**
                           * @dev This empty reserved space is put in place to allow future versions to add new
                           * variables without shifting down storage in the inheritance chain.
                           * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
                           */
                          uint256[50] private __gap;
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)
                      pragma solidity ^0.8.1;
                      /**
                       * @dev Collection of functions related to the address type
                       */
                      library AddressUpgradeable {
                          /**
                           * @dev Returns true if `account` is a contract.
                           *
                           * [IMPORTANT]
                           * ====
                           * It is unsafe to assume that an address for which this function returns
                           * false is an externally-owned account (EOA) and not a contract.
                           *
                           * Among others, `isContract` will return false for the following
                           * types of addresses:
                           *
                           *  - an externally-owned account
                           *  - a contract in construction
                           *  - an address where a contract will be created
                           *  - an address where a contract lived, but was destroyed
                           * ====
                           *
                           * [IMPORTANT]
                           * ====
                           * You shouldn't rely on `isContract` to protect against flash loan attacks!
                           *
                           * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
                           * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
                           * constructor.
                           * ====
                           */
                          function isContract(address account) internal view returns (bool) {
                              // This method relies on extcodesize/address.code.length, which returns 0
                              // for contracts in construction, since the code is only stored at the end
                              // of the constructor execution.
                              return account.code.length > 0;
                          }
                          /**
                           * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
                           * `recipient`, forwarding all available gas and reverting on errors.
                           *
                           * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
                           * of certain opcodes, possibly making contracts go over the 2300 gas limit
                           * imposed by `transfer`, making them unable to receive funds via
                           * `transfer`. {sendValue} removes this limitation.
                           *
                           * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
                           *
                           * IMPORTANT: because control is transferred to `recipient`, care must be
                           * taken to not create reentrancy vulnerabilities. Consider using
                           * {ReentrancyGuard} or the
                           * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
                           */
                          function sendValue(address payable recipient, uint256 amount) internal {
                              require(address(this).balance >= amount, "Address: insufficient balance");
                              (bool success, ) = recipient.call{value: amount}("");
                              require(success, "Address: unable to send value, recipient may have reverted");
                          }
                          /**
                           * @dev Performs a Solidity function call using a low level `call`. A
                           * plain `call` is an unsafe replacement for a function call: use this
                           * function instead.
                           *
                           * If `target` reverts with a revert reason, it is bubbled up by this
                           * function (like regular Solidity function calls).
                           *
                           * Returns the raw returned data. To convert to the expected return value,
                           * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
                           *
                           * Requirements:
                           *
                           * - `target` must be a contract.
                           * - calling `target` with `data` must not revert.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(address target, bytes memory data) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, "Address: low-level call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
                           * `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, 0, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but also transferring `value` wei to `target`.
                           *
                           * Requirements:
                           *
                           * - the calling contract must have an ETH balance of at least `value`.
                           * - the called Solidity function must be `payable`.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value
                          ) internal returns (bytes memory) {
                              return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
                           * with `errorMessage` as a fallback revert reason when `target` reverts.
                           *
                           * _Available since v3.1._
                           */
                          function functionCallWithValue(
                              address target,
                              bytes memory data,
                              uint256 value,
                              string memory errorMessage
                          ) internal returns (bytes memory) {
                              require(address(this).balance >= value, "Address: insufficient balance for call");
                              (bool success, bytes memory returndata) = target.call{value: value}(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
                              return functionStaticCall(target, data, "Address: low-level static call failed");
                          }
                          /**
                           * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
                           * but performing a static call.
                           *
                           * _Available since v3.3._
                           */
                          function functionStaticCall(
                              address target,
                              bytes memory data,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              (bool success, bytes memory returndata) = target.staticcall(data);
                              return verifyCallResultFromTarget(target, success, returndata, errorMessage);
                          }
                          /**
                           * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
                           * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
                           *
                           * _Available since v4.8._
                           */
                          function verifyCallResultFromTarget(
                              address target,
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal view returns (bytes memory) {
                              if (success) {
                                  if (returndata.length == 0) {
                                      // only check isContract if the call was successful and the return data is empty
                                      // otherwise we already know that it was a contract
                                      require(isContract(target), "Address: call to non-contract");
                                  }
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          /**
                           * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
                           * revert reason or using the provided one.
                           *
                           * _Available since v4.3._
                           */
                          function verifyCallResult(
                              bool success,
                              bytes memory returndata,
                              string memory errorMessage
                          ) internal pure returns (bytes memory) {
                              if (success) {
                                  return returndata;
                              } else {
                                  _revert(returndata, errorMessage);
                              }
                          }
                          function _revert(bytes memory returndata, string memory errorMessage) private pure {
                              // Look for revert reason and bubble it up if present
                              if (returndata.length > 0) {
                                  // The easiest way to bubble the revert reason is using memory via assembly
                                  /// @solidity memory-safe-assembly
                                  assembly {
                                      let returndata_size := mload(returndata)
                                      revert(add(32, returndata), returndata_size)
                                  }
                              } else {
                                  revert(errorMessage);
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Standard math utilities missing in the Solidity language.
                       */
                      library MathUpgradeable {
                          enum Rounding {
                              Down, // Toward negative infinity
                              Up, // Toward infinity
                              Zero // Toward zero
                          }
                          /**
                           * @dev Returns the largest of two numbers.
                           */
                          function max(uint256 a, uint256 b) internal pure returns (uint256) {
                              return a > b ? a : b;
                          }
                          /**
                           * @dev Returns the smallest of two numbers.
                           */
                          function min(uint256 a, uint256 b) internal pure returns (uint256) {
                              return a < b ? a : b;
                          }
                          /**
                           * @dev Returns the average of two numbers. The result is rounded towards
                           * zero.
                           */
                          function average(uint256 a, uint256 b) internal pure returns (uint256) {
                              // (a + b) / 2 can overflow.
                              return (a & b) + (a ^ b) / 2;
                          }
                          /**
                           * @dev Returns the ceiling of the division of two numbers.
                           *
                           * This differs from standard division with `/` in that it rounds up instead
                           * of rounding down.
                           */
                          function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
                              // (a + b - 1) / b can overflow on addition, so we distribute.
                              return a == 0 ? 0 : (a - 1) / b + 1;
                          }
                          /**
                           * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or denominator == 0
                           * @dev Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv)
                           * with further edits by Uniswap Labs also under MIT license.
                           */
                          function mulDiv(
                              uint256 x,
                              uint256 y,
                              uint256 denominator
                          ) internal pure returns (uint256 result) {
                              unchecked {
                                  // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2^256 and mod 2^256 - 1, then use
                                  // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
                                  // variables such that product = prod1 * 2^256 + prod0.
                                  uint256 prod0; // Least significant 256 bits of the product
                                  uint256 prod1; // Most significant 256 bits of the product
                                  assembly {
                                      let mm := mulmod(x, y, not(0))
                                      prod0 := mul(x, y)
                                      prod1 := sub(sub(mm, prod0), lt(mm, prod0))
                                  }
                                  // Handle non-overflow cases, 256 by 256 division.
                                  if (prod1 == 0) {
                                      return prod0 / denominator;
                                  }
                                  // Make sure the result is less than 2^256. Also prevents denominator == 0.
                                  require(denominator > prod1);
                                  ///////////////////////////////////////////////
                                  // 512 by 256 division.
                                  ///////////////////////////////////////////////
                                  // Make division exact by subtracting the remainder from [prod1 prod0].
                                  uint256 remainder;
                                  assembly {
                                      // Compute remainder using mulmod.
                                      remainder := mulmod(x, y, denominator)
                                      // Subtract 256 bit number from 512 bit number.
                                      prod1 := sub(prod1, gt(remainder, prod0))
                                      prod0 := sub(prod0, remainder)
                                  }
                                  // Factor powers of two out of denominator and compute largest power of two divisor of denominator. Always >= 1.
                                  // See https://cs.stackexchange.com/q/138556/92363.
                                  // Does not overflow because the denominator cannot be zero at this stage in the function.
                                  uint256 twos = denominator & (~denominator + 1);
                                  assembly {
                                      // Divide denominator by twos.
                                      denominator := div(denominator, twos)
                                      // Divide [prod1 prod0] by twos.
                                      prod0 := div(prod0, twos)
                                      // Flip twos such that it is 2^256 / twos. If twos is zero, then it becomes one.
                                      twos := add(div(sub(0, twos), twos), 1)
                                  }
                                  // Shift in bits from prod1 into prod0.
                                  prod0 |= prod1 * twos;
                                  // Invert denominator mod 2^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
                                  // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
                                  // four bits. That is, denominator * inv = 1 mod 2^4.
                                  uint256 inverse = (3 * denominator) ^ 2;
                                  // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also works
                                  // in modular arithmetic, doubling the correct bits in each step.
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^8
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^16
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^32
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^64
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^128
                                  inverse *= 2 - denominator * inverse; // inverse mod 2^256
                                  // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
                                  // This will give us the correct result modulo 2^256. Since the preconditions guarantee that the outcome is
                                  // less than 2^256, this is the final result. We don't need to compute the high bits of the result and prod1
                                  // is no longer required.
                                  result = prod0 * inverse;
                                  return result;
                              }
                          }
                          /**
                           * @notice Calculates x * y / denominator with full precision, following the selected rounding direction.
                           */
                          function mulDiv(
                              uint256 x,
                              uint256 y,
                              uint256 denominator,
                              Rounding rounding
                          ) internal pure returns (uint256) {
                              uint256 result = mulDiv(x, y, denominator);
                              if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
                                  result += 1;
                              }
                              return result;
                          }
                          /**
                           * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded down.
                           *
                           * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
                           */
                          function sqrt(uint256 a) internal pure returns (uint256) {
                              if (a == 0) {
                                  return 0;
                              }
                              // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
                              //
                              // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
                              // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
                              //
                              // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
                              // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
                              // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
                              //
                              // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
                              uint256 result = 1 << (log2(a) >> 1);
                              // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
                              // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
                              // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
                              // into the expected uint128 result.
                              unchecked {
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  result = (result + a / result) >> 1;
                                  return min(result, a / result);
                              }
                          }
                          /**
                           * @notice Calculates sqrt(a), following the selected rounding direction.
                           */
                          function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
                              unchecked {
                                  uint256 result = sqrt(a);
                                  return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
                              }
                          }
                          /**
                           * @dev Return the log in base 2, rounded down, of a positive value.
                           * Returns 0 if given 0.
                           */
                          function log2(uint256 value) internal pure returns (uint256) {
                              uint256 result = 0;
                              unchecked {
                                  if (value >> 128 > 0) {
                                      value >>= 128;
                                      result += 128;
                                  }
                                  if (value >> 64 > 0) {
                                      value >>= 64;
                                      result += 64;
                                  }
                                  if (value >> 32 > 0) {
                                      value >>= 32;
                                      result += 32;
                                  }
                                  if (value >> 16 > 0) {
                                      value >>= 16;
                                      result += 16;
                                  }
                                  if (value >> 8 > 0) {
                                      value >>= 8;
                                      result += 8;
                                  }
                                  if (value >> 4 > 0) {
                                      value >>= 4;
                                      result += 4;
                                  }
                                  if (value >> 2 > 0) {
                                      value >>= 2;
                                      result += 2;
                                  }
                                  if (value >> 1 > 0) {
                                      result += 1;
                                  }
                              }
                              return result;
                          }
                          /**
                           * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
                           * Returns 0 if given 0.
                           */
                          function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
                              unchecked {
                                  uint256 result = log2(value);
                                  return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
                              }
                          }
                          /**
                           * @dev Return the log in base 10, rounded down, of a positive value.
                           * Returns 0 if given 0.
                           */
                          function log10(uint256 value) internal pure returns (uint256) {
                              uint256 result = 0;
                              unchecked {
                                  if (value >= 10**64) {
                                      value /= 10**64;
                                      result += 64;
                                  }
                                  if (value >= 10**32) {
                                      value /= 10**32;
                                      result += 32;
                                  }
                                  if (value >= 10**16) {
                                      value /= 10**16;
                                      result += 16;
                                  }
                                  if (value >= 10**8) {
                                      value /= 10**8;
                                      result += 8;
                                  }
                                  if (value >= 10**4) {
                                      value /= 10**4;
                                      result += 4;
                                  }
                                  if (value >= 10**2) {
                                      value /= 10**2;
                                      result += 2;
                                  }
                                  if (value >= 10**1) {
                                      result += 1;
                                  }
                              }
                              return result;
                          }
                          /**
                           * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
                           * Returns 0 if given 0.
                           */
                          function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
                              unchecked {
                                  uint256 result = log10(value);
                                  return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
                              }
                          }
                          /**
                           * @dev Return the log in base 256, rounded down, of a positive value.
                           * Returns 0 if given 0.
                           *
                           * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
                           */
                          function log256(uint256 value) internal pure returns (uint256) {
                              uint256 result = 0;
                              unchecked {
                                  if (value >> 128 > 0) {
                                      value >>= 128;
                                      result += 16;
                                  }
                                  if (value >> 64 > 0) {
                                      value >>= 64;
                                      result += 8;
                                  }
                                  if (value >> 32 > 0) {
                                      value >>= 32;
                                      result += 4;
                                  }
                                  if (value >> 16 > 0) {
                                      value >>= 16;
                                      result += 2;
                                  }
                                  if (value >> 8 > 0) {
                                      result += 1;
                                  }
                              }
                              return result;
                          }
                          /**
                           * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
                           * Returns 0 if given 0.
                           */
                          function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
                              unchecked {
                                  uint256 result = log256(value);
                                  return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
                              }
                          }
                      }
                      // SPDX-License-Identifier: MIT
                      // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)
                      pragma solidity ^0.8.0;
                      /**
                       * @dev Interface of the ERC165 standard, as defined in the
                       * https://eips.ethereum.org/EIPS/eip-165[EIP].
                       *
                       * Implementers can declare support of contract interfaces, which can then be
                       * queried by others ({ERC165Checker}).
                       *
                       * For an implementation, see {ERC165}.
                       */
                      interface IERC165Upgradeable {
                          /**
                           * @dev Returns true if this contract implements the interface defined by
                           * `interfaceId`. See the corresponding
                           * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
                           * to learn more about how these ids are created.
                           *
                           * This function call must use less than 30 000 gas.
                           */
                          function supportsInterface(bytes4 interfaceId) external view returns (bool);
                      }